/// <summary>
/// Handle the command
/// </summary>
/// <param name="socket"></param>
/// <param name="nickname"></param>
/// <param name="rawMessage"></param>
/// <returns></returns>
public async Task <string> Handle(WebSocket socket, string nickname, string rawMessage)
{
var result = "";
var messageSplitted = rawMessage.Split(' ');
if (!IsValidCommand(messageSplitted[0].Replace("/", string.Empty), messageSplitted.Length))
{
result = ServerMessageConstants.GetMessage(ServerMessageConstants.COMMAND_INVALID, messageSplitted[0]);
await _socketHandler.SendMessage(socket, result);
}
switch (messageSplitted[0])
{
case "/p":
result = await SendPrivateMessageCommand(socket, nickname, rawMessage, messageSplitted);
break;
case "/exit":
result = await ExecuteExitCommand(socket);
break;
case "/changenickname":
result = await ChangeNickNameCommand(socket, nickname, messageSplitted);
break;
case "/help":
result = await ShowHelpListCommand(socket);
break;
}
return(result);
}
/// <summary>
/// Handle the client registration
/// </summary>
/// <param name="socket"></param>
/// <param name="nickname"></param>
/// <param name="rawMessage"></param>
/// <returns></returns>
public async Task <string> Handle(WebSocket socket, string nickname, string rawMessage)
{
var result = "";
if (!IsValidNickName(rawMessage))
{
result = ServerMessageConstants.GetMessage(ServerMessageConstants.NICKNAME_INVALID, rawMessage);
await _socketHandler.SendMessage(socket, result);
return(result);
}
if (_connectionManager.IsNickNameExists(rawMessage))
{
result = ServerMessageConstants.GetMessage(ServerMessageConstants.NICKNAME_ALREADY_TAKEN, rawMessage);
await _socketHandler.SendMessage(socket, result);
return(result);
}
if (_connectionManager.RegisterNickName(socket, rawMessage))
{
result = ServerMessageConstants.GetMessage(ServerMessageConstants.SUCCESSFULLY_REGISTERED, rawMessage);
await _socketHandler.SendMessage(socket, result);
var message = ServerMessageConstants.GetMessage(ServerMessageConstants.JOINED_GENERAL_CHANNEL, rawMessage);
await _socketHandler.SendMessageToAll(message);
}
return(result);
}
/// <summary>
/// Change client nickname
/// </summary>
/// <returns></returns>
private async Task <string> ChangeNickNameCommand(WebSocket webSocket, string nickname, string[] command)
{
_connectionManager.RegisterNickName(webSocket, command[1], nickname);
var result = ServerMessageConstants.GetMessage(ServerMessageConstants.SUCCESSFULLY_CHANGED_NICKNAME, command[1]);
await _socketHandler.SendMessage(webSocket, result);
return(result);
}
/// <summary>
/// Handle the message
/// </summary>
/// <param name="socket"></param>
/// <param name="nickname"></param>
/// <param name="rawMessage"></param>
/// <returns></returns>
public async Task <string> Handle(WebSocket socket, string nickname, string rawMessage)
{
var message = ServerMessageConstants.GetMessage(ServerMessageConstants.GENERAL_MESSAGE, nickname, rawMessage);
await _socketHandler.SendMessageToAll(message);
return(message);
}
public async Task GivenChangeNickNameCommandWhenExecutingHandleThanReturnTheCommandExecutionMessage()
{
var nickname = "foo";
var command = "/changenickname bar";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.SUCCESSFULLY_CHANGED_NICKNAME, "bar");
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <IConnectionManager> connectionManagerMock = new Mock <IConnectionManager>();
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatCommandHandler = new ChatCommandHandler(connectionManagerMock.Object, socketHandlerMock.Object);
var taskResult = await chatCommandHandler.Handle(originSocketMock.Object, nickname, command);
Assert.Equal(taskResult, expected);
}
public async Task GivenInvalidCommandWhenExecutingHandleThanReturnTheInvalidCommandErrorMessage()
{
var nickname = "foo";
var command = "/barbar";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.COMMAND_INVALID, command);
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <IConnectionManager> connectionManagerMock = new Mock <IConnectionManager>();
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatCommandHandler = new ChatCommandHandler(connectionManagerMock.Object, socketHandlerMock.Object);
var taskResult = await chatCommandHandler.Handle(originSocketMock.Object, nickname, command);
Assert.Equal(taskResult, expected);
}
public async Task GivenAMessageToAllWhenExecutingHandleThanReturnTheFormattedMessage()
{
var nickname = "foo";
var message = "message";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.GENERAL_MESSAGE, nickname, message);
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatMessageHandler = new ChatMessageHandler(socketHandlerMock.Object);
var taskResult = await chatMessageHandler.Handle(originSocketMock.Object, nickname, message);
Assert.Equal(taskResult, expected);
}
public async Task GivenAnExistingNickNameWhenExecutingHandleThanReturnTheNickNameAlreadyTakenErrorMessage()
{
var emptyNickName = "";
var newNickName = "foo";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.NICKNAME_ALREADY_TAKEN, newNickName);
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <IConnectionManager> connectionManagerMock = new Mock <IConnectionManager>();
connectionManagerMock.Setup(p => p.IsNickNameExists(It.IsAny <string>())).Returns(true);
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatCommandHandler = new ChatRegistrationHandler(connectionManagerMock.Object, socketHandlerMock.Object);
var taskResult = await chatCommandHandler.Handle(originSocketMock.Object, emptyNickName, newNickName);
Assert.Equal(taskResult, expected);
}
public async Task GivenInvalidNickNameWhenExecutingHandleThanReturnTheInvalidNickNameErrorMessage()
{
var emptyNickName = "";
var newNickName = "$foo$";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.NICKNAME_INVALID, newNickName);
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <IConnectionManager> connectionManagerMock = new Mock <IConnectionManager>();
connectionManagerMock.Setup(p => p.RegisterNickName(It.IsAny <WebSocket>(), It.IsAny <string>(), It.IsAny <string>())).Returns(true);
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatCommandHandler = new ChatRegistrationHandler(connectionManagerMock.Object, socketHandlerMock.Object);
var taskResult = await chatCommandHandler.Handle(originSocketMock.Object, emptyNickName, newNickName);
Assert.Equal(taskResult, expected);
}
public async Task GivenPrivateMessageCommandWhenExecutingHandleThanReturnTheCommandExecutionMessage()
{
var nickname = "foo";
var command = "/p bar message";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.PRIVATE_MESSAGE, nickname, "bar", "message");
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <WebSocket> targetSocketMock = new Mock <WebSocket>();
Mock <IConnectionManager> connectionManagerMock = new Mock <IConnectionManager>();
connectionManagerMock.Setup(p => p.GetSocketByNickName(It.IsAny <string>())).Returns(targetSocketMock.Object);
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatCommandHandler = new ChatCommandHandler(connectionManagerMock.Object, socketHandlerMock.Object);
var taskResult = await chatCommandHandler.Handle(originSocketMock.Object, nickname, command);
Assert.Equal(taskResult, expected);
}
/// <summary>
/// Sends a private message
/// </summary>
/// <param name="socket"></param>
/// <param name="nickname"></param>
/// <param name="rawMessage"></param>
/// <param name="command"></param>
/// <returns></returns>
private async Task <string> SendPrivateMessageCommand(WebSocket socket, string nickname, string rawMessage, string[] command)
{
var result = "";
var targetUser = command[1];
rawMessage = rawMessage.Replace(command[0], string.Empty).Replace(command[1], string.Empty).Trim();
var targetSocket = _connectionManager.GetSocketByNickName(targetUser);
if (targetSocket != null)
{
result = ServerMessageConstants.GetMessage(ServerMessageConstants.PRIVATE_MESSAGE, nickname, targetUser, rawMessage);
await _socketHandler.SendMessageToOriginTargetClients(socket, targetSocket, result);
}
else
{
result = ServerMessageConstants.GetMessage(ServerMessageConstants.USER_NOT_FOUND, targetUser);
await _socketHandler.SendMessage(socket, result);
}
return(result);
}
