public void Close_Socket()
{
var mockedServer = new MockSocketProxy();
var testServer = new Server(mockedServer);
testServer.CloseSocket();
mockedServer.VerifyClose();
}
public void Exit_Chat()
{
var mockedClient = new MockSocketProxy();
var testClient = new Client(mockedClient);
testClient.ExitClient();
mockedClient.VerifyClose();
}
public void Start_Server_And_Listen_Connections()
{
var mockedServer = new MockSocketProxy();
var testServer = new Server(mockedServer);
testServer.RunSocket(IPAddress.Parse("180.0.0.0"), 2100);
mockedServer.VerifyBind(new IPEndPoint(IPAddress.Parse("180.0.0.0"), 2100));
mockedServer.VerifyListen(6);
}
public void Add__ShouldAppendList()
{
var socket = new MockSocketProxy();
_cluster.Add(socket);
var sockets = _cluster.GetSnapshot();
Assert.Single(sockets);
Assert.Equal(socket, sockets.First());
}
public void Get_Client_IP_Address()
{
var mockedServer = new MockSocketProxy();
var testServer = new Server(mockedServer);
testServer.RunSocket(IPAddress.Parse("180.0.0.0"), 2100);
mockedServer.VerifyBind(new IPEndPoint(IPAddress.Parse("180.0.0.0"), 2100));
mockedServer.VerifyListen(6);
testServer.ReceiveConnections();
mockedServer.VerifyRemoteEndPoint();
}
public void Start_Client_And_Send_Connections()
{
var mockedClient = new MockSocketProxy();
var testClient = new Client(mockedClient);
IPAddress ip = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];
testClient.StartClient(IPAddress.Parse("180.0.0.0"), 2100);
mockedClient.VerifyConnect(IPAddress.Parse("180.0.0.0"), 2100);
byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");
mockedClient.VerifySend(msg);
}
public void Wrapped_Invalid_BiggerLength_Message_ShouldBe_Unwrapped()
{
MockSocketProxy mockSocket = new MockSocketProxy();
NormalPerson normalPerson = new NormalPerson(new Person(mockSocket));
Buffer buffer = new Buffer();
mockSocket.internalReceiveBuffer.Add(mockSocket.WrapData(new Message("test").ToByteArray(), 10));
var exception = Record.Exception(() => buffer.Read(mockSocket));
Assert.IsType(typeof(System.Exception), exception);
Assert.True(exception.Message.Contains("You've received zero bytes. Please, check your connection."));
}
public void Wrapped_Empty_Message_ShouldBe_Unwrapped()
{
MockSocketProxy mockSocket = new MockSocketProxy();
NormalPerson normalPerson = new NormalPerson(new Person(mockSocket));
Buffer buffer = new Buffer();
mockSocket.internalReceiveBuffer.Add(new Message("").WrapData());
byte[] res = buffer.Read(mockSocket);
string result = Encoding.ASCII.GetString(res);
Assert.Equal("", result);
}
public void If_NewClient_Server_AskFor_Username()
{
MockSocketProxy serverMockSocket = new MockSocketProxy();
Server testServer = new Server(serverMockSocket);
MockSocketProxy mockSocket = new MockSocketProxy();
mockSocket.internalReceiveBuffer.Add(new Message("testUserName").WrapData());
testServer.GetRoom().Login(new NormalPerson(new Person(mockSocket)));
Assert.Equal("S00", mockSocket.sentMessage[0]);
Assert.Equal("S01", mockSocket.sentMessage[1]);
}
public void If_User_Types_Input_Client_Sends_Message_()
{
MockSocketProxy mockSocket = new MockSocketProxy();
Client testClient = new Client(mockSocket);
testClient.NormalPerson = new NormalPerson(new Person(mockSocket));
mockSocket.internalReceiveBuffer.Add(new Message("Hello").WrapData());
Stack <string> stack = new Stack <string>(new string[] { "exit", "test" });
testClient.HandleConsole((Del)(() => stack.Pop()));
Assert.Equal("test", mockSocket.sentMessage[0]);
}
public void If_OnlyConnected_Person_Sends_Exit_Msg_Room_IsEmptied()
{
MockSocketProxy serverMockSocket = new MockSocketProxy();
Server testServer = new Server(serverMockSocket);
Room testRoom = testServer.GetRoom();
MockSocketProxy mockSocket = new MockSocketProxy();
NormalPerson testPerson = new NormalPerson(new Person("testUserName", mockSocket));
testRoom.Join(testPerson);
mockSocket.internalReceiveBuffer.Add(new Message("exit").WrapData());
testServer.HandleCommunication(testPerson, () => testPerson.ReceiveMessage());
Assert.True(testRoom.IsRoomEmpty());
}
public void If_Unique_UserName_Client_Should_Login()
{
MockSocketProxy mockSocket = new MockSocketProxy();
Client testClient = new Client(mockSocket);
testClient.NormalPerson = new NormalPerson(new Person(mockSocket));
mockSocket.internalReceiveBuffer.Add(new Message("S00").WrapData());
mockSocket.internalReceiveBuffer.Add(new Message("S01").WrapData());
Stack <string> stack = new Stack <string>(new string[] { "testUserName" });
testClient.LoginProcess(() => stack.Pop());
Assert.Equal("testUserName", mockSocket.sentMessage[0]);
}
public void If_Unique_UserName_Client_ShouldSet_UserName_OnPerson()
{
MockSocketProxy mockSocket = new MockSocketProxy();
Client testClient = new Client(mockSocket);
testClient.NormalPerson = new NormalPerson(new Person(mockSocket));
mockSocket.internalReceiveBuffer.Add(new Message("S00").WrapData());
mockSocket.internalReceiveBuffer.Add(new Message("S01").WrapData());
Queue <string> queue = new Queue <string>(new string[] { "testUserName" });
testClient.LoginProcess(() => queue.Dequeue());
Assert.Equal("testUserName", testClient.NormalPerson.Name);
}
private void _addClients(int n = 5)
{
var sockets = new ISocketProxy[n];
for (var i = 0; i < sockets.Length; i++)
{
sockets[i] = new MockSocketProxy();
}
foreach (var socket in sockets)
{
_cluster.Add(socket);
}
}
public void If_Duplicate_UserName_NewPersonName_Is_Set_To_New_UserName()
{
MockSocketProxy mockSocket = new MockSocketProxy();
Client testClient = new Client(mockSocket);
testClient.NormalPerson = new NormalPerson(new Person(mockSocket));
mockSocket.internalReceiveBuffer.Add(new Message("S00").WrapData());
mockSocket.internalReceiveBuffer.Add(new Message("E00").WrapData());
mockSocket.internalReceiveBuffer.Add(new Message("S01").WrapData());
Stack <string> stack = new Stack <string>(new string[] { "testUserNameOne", "testUserNameTwo" });
testClient.LoginProcess(() => stack.Pop());
Assert.Equal("testUserNameOne", testClient.NormalPerson.Name);
}
public void If_Duplicate_UserName_Login_Must_Provide_Another_UserName()
{
MockSocketProxy mockSocket = new MockSocketProxy();
Client testClient = new Client(mockSocket);
testClient.NormalPerson = new NormalPerson(new Person(mockSocket));
mockSocket.internalReceiveBuffer.Add(new Message("S00").WrapData());
mockSocket.internalReceiveBuffer.Add(new Message("E00").WrapData());
mockSocket.internalReceiveBuffer.Add(new Message("S01").WrapData());
Stack <string> stack = new Stack <string>(new string[] { "testUserNameOne", "testUserNameTwo" });
testClient.LoginProcess(() => stack.Pop());
Assert.Equal("testUserNameTwo", mockSocket.sentMessage[0]);
Assert.Equal("testUserNameOne", mockSocket.sentMessage[1]);
}
public void If_LoggedIn_Person_Sends_Msg_Server_Answers_With_Broadcast()
{
MockSocketProxy serverMockSocket = new MockSocketProxy();
Server testServer = new Server(serverMockSocket);
Room testRoom = testServer.GetRoom();
MockSocketProxy mockSocketOne = new MockSocketProxy();
MockSocketProxy mockSocketTwo = new MockSocketProxy();
NormalPerson testPersonOne = new NormalPerson(new Person("testUserNameOne", mockSocketOne));
NormalPerson testPersonTwo = new NormalPerson(new Person("testUserNameTwo", mockSocketTwo));
mockSocketOne.internalReceiveBuffer.Add(new Message("test").WrapData());
mockSocketOne.internalReceiveBuffer.Add(new Message("exit").WrapData());
mockSocketTwo.internalReceiveBuffer.Add(new Message("exit").WrapData());
testRoom.Join(testPersonOne);
testRoom.Join(testPersonTwo);
testServer.HandleCommunication(testPersonOne, () => testPersonOne.ReceiveMessage());
testServer.HandleCommunication(testPersonTwo, () => testPersonTwo.ReceiveMessage());
Assert.Equal("testUserNameOne: test", mockSocketTwo.sentMessage[0]);
Assert.Equal("testUserNameOne is offline.", mockSocketTwo.sentMessage[1]);
}
public void If_Duplicate_UserName_Server_AsksFor_AnotherUsername()
{
MockSocketProxy serverMockSocket = new MockSocketProxy();
Server testServer = new Server(serverMockSocket);
Room testRoom = testServer.GetRoom();
MockSocketProxy mockSocketOne = new MockSocketProxy();
NormalPerson testPersonOne = new NormalPerson(new Person(mockSocketOne));
mockSocketOne.internalReceiveBuffer.Add(new Message("testUserNameOne").WrapData());
testRoom.Login(testPersonOne);
MockSocketProxy mockSocketTwo = new MockSocketProxy();
NormalPerson testPersonTwo = new NormalPerson(new Person(mockSocketTwo));
mockSocketTwo.internalReceiveBuffer.Add(new Message("testUserNameOne").WrapData());
mockSocketTwo.internalReceiveBuffer.Add(new Message("testUserNameTwo").WrapData());
testRoom.Login(testPersonTwo);
Assert.Equal("S00", mockSocketTwo.sentMessage[0]);
Assert.Equal("E00", mockSocketTwo.sentMessage[1]);
}
public SocketManagerTests()
{
_listener = new MockSocketProxy();
_socketCluster = new SocketCluster(1000);
_socketManager = new SocketManager(_listener, _socketCluster);
}
