コード例 #1
0
        public void Receive_ReplyToReceivedObject_ObjectIsSentBack()
        {
            //Arrange
            string replayPayload  = null;
            Client client         = new Client("10.0.0.1", 123);
            var    networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel()
                                    .OnSendHandle((Client, payload) => replayPayload = payload);


            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            transport.Receive <MockObjectMessage>()
            .Reply(o =>
            {
                MockObjectMessage sendBack = new MockObjectMessage();
                sendBack.Property1_string  = "Reply message";
                sendBack.Property2_int     = 12;
                sendBack.Property3_decimal = 1.33M;

                return(sendBack);
            })
            .Execute();


            networkChannel.SimulateClientConnect(client);
            networkChannel.SimulateClientResponse(client,
                                                  "OTransport.tests.MockObjectMessage, ObjectTransport.Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null::{\"Property1_string\":\"Test String\",\"Property2_int\":12,\"Property3_decimal\":1.33}"
                                                  );

            //Assert
            Assert.AreEqual("OTransport.tests.MockObjectMessage, ObjectTransport.Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null::{\"Property1_string\":\"Reply message\",\"Property2_int\":12,\"Property3_decimal\":1.33}", replayPayload);
        }
コード例 #2
0
        public void Receive_ObjectType_ObjectReceiveFunctionExecuted()
        {
            //Arrange

            Client client         = new Client("10.0.0.1", 123);
            var    networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel();

            MockObjectMessage receive = new MockObjectMessage();

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            transport.Receive <MockObjectMessage>(o =>
            {
                receive = o;
            }
                                                  )
            .Execute();

            networkChannel.SimulateClientConnect(client);
            networkChannel.SimulateClientResponse(client,
                                                  "OTransport.tests.MockObjectMessage, ObjectTransport.Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null::{\"Property1_string\":\"Test String\",\"Property2_int\":12,\"Property3_decimal\":1.33}"
                                                  );
            //Assert
            Assert.AreEqual("Test String", receive.Property1_string);
            Assert.AreEqual(12, receive.Property2_int);
            Assert.AreEqual(1.33M, receive.Property3_decimal);
        }
コード例 #3
0
        public void TCPClient_SendUnreliably_ExceptionThrown()
        {
            //Arrange
            Client client           = null;
            Client clientDisconnect = null;

            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(Server);

            serverObjectTransport.Start("127.0.0.1", 0);

            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(Client1);

            clientObjectTransport.OnClientDisconnect(c => clientDisconnect = c);
            clientObjectTransport.Start("127.0.0.1", Server.LocalPort);

            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 1);

            client = clientObjectTransport.GetConnectedClients().First();
            Utilities.WaitFor(ref client);

            var message = new MockObjectMessage();

            //Act

            clientObjectTransport.Send(message)
            .Unreliable()
            .Execute();
        }
コード例 #4
0
        public void TCPClient_ObjectTransportStartCalled_ServerIsAddedAsClient()
        {
            //Arrange
            Client client = null;

            server.Start("127.0.0.1", 0);
            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(server);

            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransportTCPclient();

            clientObjectTransport.Start("127.0.0.1", server.LocalPort);

            //When the start method is called, there should be clients
            client = clientObjectTransport.GetConnectedClients().First();

            Utilities.WaitFor(ref client);
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 1);

            //Act


            //Assert
            Assert.AreEqual(client.IPAddress, "127.0.0.1");
            Assert.AreEqual(client.Port, server.LocalPort);
        }
コード例 #5
0
        public void SendWithResponse_ObjectWithPropertiesSet_PayloadWithObjectAndTokenSent()
        {
            //Arrange
            var sentPayload    = string.Empty;
            var client         = new Client("10.0.0.1", 123);
            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel()
                                 .OnSendHandle((Client, payload) => sentPayload = payload);

            MockObjectMessage sendObject = new MockObjectMessage();

            sendObject.Property1_string  = "Test String";
            sendObject.Property2_int     = 12;
            sendObject.Property3_decimal = 1.33M;

            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            networkChannel.SimulateClientConnect(client);

            //Act

            transport.Send(sendObject)
            .Response <MockObjectMessage>(o => o.GetType())
            .Execute();


            Utilities.WaitFor(ref sentPayload);

            //Assert
            Regex rgx = new Regex(typeof(MockObjectMessage).AssemblyQualifiedName + "::(.*)::{\"Property1_string\":\"Test String\",\"Property2_int\":12,\"Property3_decimal\":1.33}");

            Assert.IsTrue(rgx.IsMatch(sentPayload));
        }
コード例 #6
0
        public void SendReceiveThroughChannel_ObjectTransportConnectedChannel_ObjectSentAndReceivedBetweenClients()
        {
            //Arrange
            var joinedNetworkChannels = MockNetworkChannelFactory.GetConnectedChannels();

            MockObjectMessage sendMessage = new MockObjectMessage();

            sendMessage.Property1_string  = "test send";
            sendMessage.Property2_int     = 123;
            sendMessage.Property3_decimal = 56M;

            MockObjectMessage receivedMessage = null;

            //Act
            ObjectTransport client1 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item1);

            client1.Receive <MockObjectMessage>(o =>
            {
                receivedMessage = o;
            })
            .Execute();


            ObjectTransport client2 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item2);

            client2.Send(sendMessage)
            .Execute();

            Utilities.WaitFor(ref receivedMessage);

            //Assert
            Assert.AreEqual(sendMessage.Property3_decimal, receivedMessage.Property3_decimal);
            Assert.AreEqual(sendMessage.Property1_string, receivedMessage.Property1_string);
            Assert.AreEqual(sendMessage.Property2_int, receivedMessage.Property2_int);
        }
コード例 #7
0
        public void UDPClient_ClientDisconnectsServer_ServerOnClientDisconnectCalled()
        {
            //Arrange
            Client disconnectedClient = null;
            Client connectedServer    = null;

            udpServer = new UDPServerChannel("127.0.0.1", 0, 32);
            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpServer);

            serverObjectTransport.OnClientDisconnect(c => disconnectedClient = c);

            udpClient = new UDPClientChannel("127.0.0.1", udpServer.LocalPort);
            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpClient);

            clientObjectTransport.OnClientConnect(c => connectedServer = c);

            udpClient2 = new UDPClientChannel("127.0.0.1", udpServer.LocalPort);
            ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(udpClient2);

            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, udpClient.LocalPort);
        }
コード例 #8
0
        public void SendExecute_ObjectWithProperties_PayloadWithObjectAndTypeSent()
        {
            //Arrange
            var sentPayload    = string.Empty;
            var client         = new Client("10.0.0.1", 123);
            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel()
                                 .OnSendHandle((Client, payload) => sentPayload = payload);

            MockObjectMessage sendObject = new MockObjectMessage();

            sendObject.Property1_string  = "Test String";
            sendObject.Property2_int     = 12;
            sendObject.Property3_decimal = 1.33M;

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            networkChannel.SimulateClientConnect(client);
            transport.Send(sendObject)
            .To(client)
            .Execute();

            //Assert
            Assert.AreEqual(typeof(MockObjectMessage).AssemblyQualifiedName + "::{\"Property1_string\":\"Test String\",\"Property2_int\":12,\"Property3_decimal\":1.33}", sentPayload);
        }
コード例 #9
0
        public void ClientDisconnectsServer_ServerOnClientDisconnectCalled()
        {
            //Arrange
            //Create a second client
            ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(Client2);

            clientObjectTransport2.Start("127.0.0.1", Server.LocalPort);

            //Wait for the connection to have been made
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 2);

            //Act

            //disconnect the server from the client
            Client1ObjectTransport.DisconnectClient();

            Utilities.WaitFor(() => ServerOnDisconnectClients.Count == 1);

            //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(ServerOnDisconnectClients.First().Port, Client1.LocalPort);
        }
コード例 #10
0
        public void UDPServerWith2Clients_Disconnect1Client_1ClientDisconnected()
        {
            //Arrange
            Client disconnectedClient = null;

            udpServer = new UDPServerChannel("127.0.0.1", 0, 32);
            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpServer);

            serverObjectTransport.OnClientDisconnect(c => disconnectedClient = c);

            udpClient = new UDPClientChannel("127.0.0.1", udpServer.Port);
            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpClient);

            udpClient2 = new UDPClientChannel("127.0.0.1", udpServer.Port);
            ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(udpClient2);

            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);
        }
コード例 #11
0
        public void UDPServerWith2Clients_Disconnect2Client_AllClientsDisconnected()
        {
            //Arrange
            List <Client> disconnectedClients = new List <Client>();

            udpServer = new UDPServerChannel("127.0.0.1", 0, 32);
            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpServer);

            serverObjectTransport.OnClientDisconnect(c => disconnectedClients.Add(c));

            udpClient = new UDPClientChannel("127.0.0.1", udpServer.Port);
            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpClient);

            udpClient2 = new UDPClientChannel("127.0.0.1", udpServer.Port);
            ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(udpClient2);

            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());
        }
コード例 #12
0
        public void SendToAll_Except2Client_AllClientsExcept2AreSendTo()
        {
            //Arrange
            var client1 = new Client("10.0.0.1", 123);
            var client2 = new Client("10.0.0.2", 123);
            var client3 = new Client("10.0.0.3", 123);

            var clientsSendTo = new List <Client>();

            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel()
                                 .OnSendHandle((Client, paylaod) => clientsSendTo.Add(Client));

            MockObjectMessage sendObject = new MockObjectMessage();

            sendObject.Property1_string  = "Test String";
            sendObject.Property2_int     = 12;
            sendObject.Property3_decimal = 1.33M;

            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            networkChannel.SimulateClientConnect(client1);
            networkChannel.SimulateClientConnect(client2);
            networkChannel.SimulateClientConnect(client3);

            //Act

            transport.Send(sendObject)
            .Response <MockObjectMessage>(o => o.GetType())
            .ToAllExcept(client1, client3)
            .Execute();

            //Assert
            Assert.AreEqual(1, clientsSendTo.Count);
            Assert.AreEqual(clientsSendTo[0].IPAddress, "10.0.0.2");
        }
コード例 #13
0
        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());
        }
コード例 #14
0
        public void Receive_InvalidPayload_PayloadNotProcessed()
        {
            //Arrange

            Client client         = new Client("10.0.0.1", 123);
            var    networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel();

            MockObjectMessage receive = null;

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            transport.Receive <MockObjectMessage>(o =>
            {
                receive = o;
            }
                                                  )
            .Execute();

            networkChannel.SimulateClientConnect(client);
            networkChannel.SimulateClientResponse(client,
                                                  "{\"Type\":\"OTransport.tests.MockObjectMessage, ObjectTransport.Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\",:{\"Property1_string\":\"Test String\",\"Property2_int\":12,\"Property3_decimal\":1.33}}"
                                                  );

            //Assert
            Assert.IsNull(receive);
        }
コード例 #15
0
        public void UDPClient_ServerDisconnects_ClientDisconnectCallbackCalled()
        {
            //Arrange
            Client client           = null;
            Client clientDisconnect = null;

            udpServer = new UDPServerChannel("127.0.0.1", 0, 32);
            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpServer);

            udpClient = new UDPClientChannel("127.0.0.1", udpServer.LocalPort);
            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpClient);

            clientObjectTransport.OnClientDisconnect(c => clientDisconnect = c);
            client = clientObjectTransport.GetConnectedClients().First();

            Utilities.WaitFor(ref client);
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 1);
            //Act

            serverObjectTransport.Stop();

            Utilities.WaitFor(ref clientDisconnect);

            //Assert
            Assert.AreEqual(client.IPAddress, "127.0.0.1");
            Assert.AreEqual(clientDisconnect.IPAddress, "127.0.0.1");
            Assert.AreEqual(clientDisconnect, client);
            Utilities.WaitFor(() => clientObjectTransport.GetConnectedClients().Count() == 0);
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 0);
        }
コード例 #16
0
        public void OnFailedReceived_InvalidPayloadReceived_OnFailHandleExecuted()
        {
            //Arrange

            Client          client          = new Client("10.0.0.1", 123);
            ReceivedMessage receivedMessage = null;
            Exception       failedException = null;
            var             networkChannel  = MockNetworkChannelFactory.GetMockedNetworkChannel();

            MockObjectMessage receive = new MockObjectMessage();

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            transport.Receive <MockObjectMessage>(o =>
            {
                receive = o;
            }
                                                  )
            .Execute();

            transport.OnFailedReceive((r, e) =>
            {
                receivedMessage = r;
                failedException = e;
            });

            networkChannel.SimulateClientConnect(client);
            networkChannel.SimulateClientResponse(client, "OTransport.tests.NOTHING, ObjectTransport.Test, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nullProperty1_string\":\"Test String\",\"Property2_int\":12,\"Property3_decimal\":1.33}");

            Assert.IsNotNull(receivedMessage);
            Assert.IsNotNull(failedException);
        }
コード例 #17
0
        public void Receive_ObjectWithBinaryProperty_BinaryReceived()
        {
            //Arrange
            var joinedNetworkChannels = MockNetworkChannelFactory.GetConnectedChannels();

            MockObjectMessageWithBinary sendMessage = new MockObjectMessageWithBinary();

            sendMessage.Property2_String = "Message with binary";
            sendMessage.Property1_Bytes  = Encoding.ASCII.GetBytes("hello world");

            MockObjectMessageWithBinary receivedMessage = null;
            Client receivedClient = null;

            //Act
            ObjectTransport client1 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item1);

            client1.Receive <MockObjectMessageWithBinary>((c, o) =>
            {
                receivedClient  = c;
                receivedMessage = o;
            })
            .Execute();


            ObjectTransport client2 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item2);

            client2.Send(sendMessage)
            .Execute();

            //Assert
            Assert.AreEqual("hello world", System.Text.Encoding.UTF8.GetString(receivedMessage.Property1_Bytes));
            Assert.AreEqual(receivedMessage.Property2_String, "Message with binary");
            Assert.AreEqual("10.0.0.2", receivedClient.IPAddress);
        }
コード例 #18
0
        protected void SetUpNetworkChannels(INetworkChannel client, INetworkChannel client2, INetworkChannel server)
        {
            Client1 = client;
            Client2 = client2;
            Server  = server;

            ServerOnConnectClients     = new List <Client>();
            ServerOnDisconnectClients  = new List <Client>();
            Client1OnConnectClients    = new List <Client>();
            Client1OnDisconnectClients = new List <Client>();

            serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(Server);
            serverObjectTransport.OnClientConnect(c => ServerOnConnectClients.Add(c));
            serverObjectTransport.OnClientDisconnect(c => ServerOnDisconnectClients.Add(c));
            serverObjectTransport.Start("127.0.0.1", 0);

            Utilities.WaitFor(() => server.LocalPort != 0);

            Client1ObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(Client1);
            Client1ObjectTransport.OnClientConnect(c => Client1OnConnectClients.Add(c));
            Client1ObjectTransport.OnClientDisconnect(c => Client1OnDisconnectClients.Add(c));
            Client1ObjectTransport.Start("127.0.0.1", Server.LocalPort);

            //Wait for the connection to have been made
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 1);
            Utilities.WaitFor(() => Client1ObjectTransport.GetConnectedClients().Count() == 1);
        }
コード例 #19
0
        public void Receve_RegisterSameTypeTwice_ObjectTransportExceptionThrown()
        {
            //Arrange
            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel();

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            transport.Receive <MockObjectMessage>().Execute();
            transport.Receive <MockObjectMessage>().Execute();
        }
コード例 #20
0
        public static Tuple <ObjectTransport, ObjectTransport> GetConnectObjectTransports()
        {
            server.Start("127.0.0.1", 0);

            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(server);

            tcpclient.Start("127.0.0.1", server.LocalPort);
            ObjectTransport client = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);

            Tuple <ObjectTransport, ObjectTransport> result = new Tuple <ObjectTransport, ObjectTransport>(serverObjectTransport, client);

            return(result);
        }
コード例 #21
0
        public static Tuple <ObjectTransport, ObjectTransport> GetConnectObjectTransports()
        {
            server = new UDPServerChannel("127.0.0.1", 0, 32);

            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(server);

            udpclient = new UDPClientChannel("127.0.0.1", server.Port);
            ObjectTransport client = TestObjectTransportFactory.CreateNewObjectTransport(udpclient);

            Tuple <ObjectTransport, ObjectTransport> result = new Tuple <ObjectTransport, ObjectTransport>(serverObjectTransport, client);

            return(result);
        }
コード例 #22
0
        public void SendReceiveReplyThroughChannel_TwoObjectTransportsConnected_SameTokenUsed()
        {
            //Arrange
            var client2ReceiveFunctionCalled = false;
            var client2RespondFunctionCalled = false;
            var joinedNetworkChannels        = MockNetworkChannelFactory.GetConnectedChannels();

            MockObjectMessage sendMessage = new MockObjectMessage();

            sendMessage.Property1_string  = "test send";
            sendMessage.Property2_int     = 123;
            sendMessage.Property3_decimal = 56M;

            MockObjectMessage receivedMessage = null;

            //Act
            ObjectTransport client1 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item1);

            client1.Receive <MockObjectMessage>()
            .Reply((c, o) =>
            {
                o.Property1_string = "replied";
                return(o);
            })
            .Execute();


            ObjectTransport client2 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item2);

            client2.Send(sendMessage)
            .Response <MockObjectMessage>(o =>
            {
                client2RespondFunctionCalled = true;
                receivedMessage = o;
            })
            .Execute();

            client2.Receive <MockObjectMessage>(o =>
            {
                client2ReceiveFunctionCalled = true;
                receivedMessage = o;
            }).Execute();

            Utilities.WaitFor(ref receivedMessage);

            //Assert
            Assert.IsFalse(client2ReceiveFunctionCalled);
            Assert.IsTrue(client2RespondFunctionCalled);
        }
コード例 #23
0
        public void TimeOut_MessageSentToMultipleClientsWithSomeResponding_TimeOutFunctionReturnsClientsWhoDidNotRespond()
        {
            //Arrange
            var client1 = new Client("10.0.0.1", 123);
            var client2 = new Client("10.0.0.2", 123);
            var client3 = new Client("10.0.0.3", 123);

            Client[]          clientsWhoDidNotRespond = null;
            MockObjectMessage messageThatTimedOut     = null;

            var sentPayload    = string.Empty;
            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel()
                                 .OnSendHandle((Client, payload) => sentPayload = payload);

            MockObjectMessage sendObject = new MockObjectMessage();

            sendObject.Property1_string  = "Test String";
            sendObject.Property2_int     = 12;
            sendObject.Property3_decimal = 1.33M;

            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            networkChannel.SimulateClientConnect(client1);
            networkChannel.SimulateClientConnect(client2);
            networkChannel.SimulateClientConnect(client3);

            //Act
            transport.Send(sendObject)
            .Response <MockObjectMessage>(o => { })
            .SetTimeOut(2)
            .OnTimeOut(
                (c, o) => {
                clientsWhoDidNotRespond = c;
                messageThatTimedOut     = o;
            })
            .ToAll()
            .Execute();

            //Echo back the message
            networkChannel.SimulateClientResponse(client2, sentPayload);

            Utilities.WaitFor(ref messageThatTimedOut);

            //Assert
            Assert.AreEqual(2, clientsWhoDidNotRespond.Length);
            Assert.IsTrue(clientsWhoDidNotRespond.Contains(client1));
            Assert.IsTrue(clientsWhoDidNotRespond.Contains(client3));
            Assert.AreEqual(sendObject, messageThatTimedOut);
        }
コード例 #24
0
        public void OnClientConnect_ClientConnectsToObject_ClientInjectedIntoAction()
        {
            //Arrange
            var sentJson       = string.Empty;
            var client         = new Client("10.0.0.1", 123);
            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel();

            Client connectedClient = null;

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            transport.OnClientConnect(c =>
            {
                connectedClient = c;
            });

            networkChannel.SimulateClientConnect(client);
            //Assert
            Assert.AreEqual(client, connectedClient);
        }
コード例 #25
0
        public void ReceiveReply_WithClientAction_ObjectAndClientInjectedInToAction()
        {
            //Arrange
            var joinedNetworkChannels = MockNetworkChannelFactory.GetConnectedChannels();

            MockObjectMessage sendMessage = new MockObjectMessage();

            sendMessage.Property1_string  = "test send";
            sendMessage.Property2_int     = 123;
            sendMessage.Property3_decimal = 56M;

            MockObjectMessage receivedMessage = null;
            Client            receivedClient  = null;

            //Act
            ObjectTransport client1 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item1);

            client1.Receive <MockObjectMessage>()
            .Reply((c, o) =>
            {
                receivedMessage = o;
                receivedClient  = c;
                return(null);
            })
            .Execute();


            ObjectTransport client2 = TestObjectTransportFactory.CreateNewObjectTransport(joinedNetworkChannels.Item2);

            client2.Send(sendMessage)
            .Execute();

            Utilities.WaitFor(ref receivedMessage);

            //Assert
            Assert.AreEqual(sendMessage.Property3_decimal, receivedMessage.Property3_decimal);
            Assert.AreEqual(sendMessage.Property1_string, receivedMessage.Property1_string);
            Assert.AreEqual(sendMessage.Property2_int, receivedMessage.Property2_int);
            Assert.AreEqual("10.0.0.2", receivedClient.IPAddress);
        }
コード例 #26
0
        public void UDPServer_SendObject_CorrectObjectSent()
        {
            //Arrange
            MockObjectMessage receivedObject = null;

            udpServer = new UDPServerChannel("127.0.0.1", 0, 32);

            Client client = null;

            ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpServer);

            serverObjectTransport.OnClientConnect(c => client = c);

            udpClient = new UDPClientChannel("127.0.0.1", udpServer.Port);
            ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(udpClient);

            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);
        }
コード例 #27
0
        public void TimeOut_TimeOutFunctionSet_TimeOutFunctionCalled()
        {
            //Arrange
            var client = new Client("10.0.0.1", 123);

            Client[]          clientsWhoDidNotRespond = null;
            MockObjectMessage messageThatTimedOut     = null;

            var sentPayload    = string.Empty;
            var networkChannel = MockNetworkChannelFactory.GetMockedNetworkChannel()
                                 .OnSendHandle((Client, payload) => sentPayload = payload);

            MockObjectMessage sendObject = new MockObjectMessage();

            sendObject.Property1_string  = "Test String";
            sendObject.Property2_int     = 12;
            sendObject.Property3_decimal = 1.33M;

            //Act
            ObjectTransport transport = TestObjectTransportFactory.CreateNewObjectTransport(networkChannel);

            networkChannel.SimulateClientConnect(client);

            transport.Send(sendObject)
            .Response <MockObjectMessage>(o => { })
            .SetTimeOut(1)
            .OnTimeOut(
                (c, o) => {
                clientsWhoDidNotRespond = c;
                messageThatTimedOut     = o;
            })
            .Execute();

            Utilities.WaitFor(ref clientsWhoDidNotRespond);

            //Assert
            Assert.AreEqual(1, clientsWhoDidNotRespond.Length);
            Assert.AreEqual(sendObject, messageThatTimedOut);
        }
コード例 #28
0
        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");
        }
コード例 #29
0
        public void ServerWith2Clients_ServerDisconnects1Client_1ClientDisconnected()
        {
            //Arrange
            ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(Client2);

            clientObjectTransport2.Start("127.0.0.1", Server.LocalPort);

            //Wait for the connection to have been made
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 2);
            var FirstClient = serverObjectTransport.GetConnectedClients().First();

            //Act

            serverObjectTransport.DisconnectClient(FirstClient);
            Utilities.WaitFor(() => ServerOnDisconnectClients.Count() == 1);

            //Assert

            Client LastClient = serverObjectTransport.GetConnectedClients().First();

            Assert.AreEqual(1, serverObjectTransport.GetConnectedClients().Count());
            Assert.AreNotEqual(FirstClient.Port, LastClient.Port);
        }
コード例 #30
0
        public void Server_ServerDisconnects2Client_AllClientsDisconnected()
        {
            //Arrange

            //Create a second client
            ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(Client2);

            clientObjectTransport2.Start("127.0.0.1", Server.LocalPort);

            //Wait for the connection to have been made
            Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 2);

            //Act

            var allClients = serverObjectTransport.GetConnectedClients().ToArray();

            serverObjectTransport.DisconnectClient(allClients);

            Utilities.WaitFor(() => ServerOnDisconnectClients.Count == 2);

            //Assert
            Assert.AreEqual(0, serverObjectTransport.GetConnectedClients().Count());
            Assert.AreEqual(2, ServerOnDisconnectClients.Count());
        }