public void DeleteMessagesWorking()
{
List <Chat> chats = chatController.GetChatsByName("", profileId);
Chat chat = chats[chats.Count - 1];
Message message = controller.CreateMessage(profileId, "test", chat.ActivityId);
Assert.AreEqual(true, controller.DeleteMessage(profileId, message.ActivityId));
}
public async Task DeleteMessage_ShouldDeleteMessage_AndreturnNoContentResult_WhenTheUserIsTheAuthorOfTheMessage()
{
// Arrange
const int messageId = 1;
_mediatorMock
.Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
_mediatorMock
.Setup(m => m.Send(It.IsAny <IsAuthorOfMessageQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
_mediatorMock
.Setup(m => m.Send(It.IsAny <DeleteMessageCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
MessageController controller = new MessageController(null, _mediatorMock.Object);
// Act
ActionResult response = await controller.DeleteMessage(messageId);
// Assert
Assert.IsType <NoContentResult>(response);
_mediatorMock.Verify(m => m.Send(It.IsAny <DeleteMessageCommand>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task DeleteMessage_ShouldReturnForbiddenResult_WhenTheUserIsNotTheAuthorOfTheMessage()
{
// Arrange
const int messageId = 1;
_mediatorMock
.Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
_mediatorMock
.Setup(m => m.Send(It.IsAny <IsAuthorOfMessageQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
MessageController controller = new MessageController(null, _mediatorMock.Object);
// Act
ActionResult response = await controller.DeleteMessage(messageId);
// Assert
ObjectResult result = Assert.IsType <ObjectResult>(response);
ErrorResource error = Assert.IsType <ErrorResource>(result.Value);
Assert.NotNull(error);
Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode);
}
public void DeleteMessage(User user)
{
Console.Clear();
Console.WriteLine("You can delete messages that only you have sent");
Console.WriteLine("");
MessageController messageController = new MessageController();
var messagesSended = messageController.RetrieveMessagesBySender(user.Id);
if (messagesSended.Count == 0)
{
Console.WriteLine("You do not have messages sent");
Console.WriteLine("Press something to return");
Console.ReadKey();
return;
}
foreach (var item in messagesSended)
{
Console.WriteLine(
$"MessageId: {item.MessageId}, " +
$"DateOfSubmission: {item.DateOfSubmission.ToString(CultureInfo.GetCultureInfo("el-GR"))}, " +
$"messageData: {item.MessageData}, " +
$"receiver: {item.Receiver.UserName},");
}
bool value = true;
int checkId;
List <int> messagesId = messagesSended.Select(x => x.MessageId).ToList();
do
{
Console.WriteLine("");
Console.WriteLine("Choose the messageId of the message you want to delete or press 0 to return back");
bool success = int.TryParse(Console.ReadLine(), out checkId);
if (success)
{
if (checkId == 0)
{
return;
}
if (messagesId.Contains(checkId))
{
value = false;
}
}
} while (value);
try
{
messageController.DeleteMessage(checkId);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.Clear();
Console.WriteLine("Message Deleted");
Console.WriteLine("Press something to exit");
Console.ReadKey();
}
public async Task DeleteMessageBadRequestStatus()
{
//Arrange
Message message = new Message {
MessageId = 1, RecipientDeleted = true, SenderDeleted = true
};
wrapperMock.Setup(m => m.MessageRepository.GetMessage(1)).Returns(Task.Run(() =>
{
return(message);
}));
wrapperMock.Setup(m => m.MessageRepository.Delete(message)).Verifiable();
wrapperMock.Setup(m => m.SaveAll()).Returns(Task.Run(() =>
{
return(false);
}));
MessageController controller = new MessageController(wrapperMock.Object, mapperMock.Object);
//Act
var action = await controller.DeleteMessage(1, 1, "any") as BadRequestObjectResult;
//Assert
Assert.Equal(400, action.StatusCode);
Assert.NotNull(action.Value);
}
public async Task DeleteMessageOkStatus()
{
//Arrange
Message message = new Message {
MessageId = 1, RecipientDeleted = true, SenderDeleted = true
};
wrapperMock.Setup(m => m.MessageRepository.GetMessage(1)).Returns(Task.Run(() =>
{
return(message);
}));
wrapperMock.Setup(m => m.MessageRepository.Delete(message)).Verifiable();
wrapperMock.Setup(m => m.SaveAll()).Returns(Task.Run(() =>
{
return(true);
}));
MessageController controller = new MessageController(wrapperMock.Object, mapperMock.Object);
//Act
var action = await controller.DeleteMessage(1, 1, "any") as OkResult;
//Assert
wrapperMock.Verify(w => w.MessageRepository.Delete(message), Times.Once);
Assert.Equal(200, action.StatusCode);
Assert.True(message.RecipientDeleted);
Assert.True(message.SenderDeleted);
}
public async Task DeleteMessage_ServiceInvoke()
{
//Act
await _messageController.DeleteMessage(It.IsAny <Guid>());
//Assert
_messageServiceMock.Verify(s => s.DeleteMessage(It.IsAny <Guid>()));
}
public async void DeleteMessageBadRequest()
{
// Arrange
var mock = new Mock <IMessageRepository>();
MessageController controller = new MessageController(mock.Object);
// Act
await controller.DeleteMessage(int.MinValue);
// Assert
mock.Verify(rep => rep.RemoveMessageAsync(It.IsAny <int>()), Times.Never);
}
public async void DeleteMessageNotFound()
{
// Arrange
var mock = new Mock <IMessageRepository>();
mock.SetupSequence(rep => rep.GetMessageByIdAsync(It.IsAny <int>())).Returns(Task <Message> .Run(() => default(Message)));
MessageController controller = new MessageController(mock.Object);
// Act
NotFoundResult model = await controller.DeleteMessage(int.MaxValue) as NotFoundResult;
// Assert
mock.Verify(rep => rep.RemoveMessageAsync(int.MaxValue), Times.Never);
}
public async Task DeleteMessageNotFoundStatus()
{
//Arrange
wrapperMock.Setup(w => w.MessageRepository.GetMessage(It.IsAny <int>())).Returns(Task.FromResult((Message)null));
MessageController controller = new MessageController(wrapperMock.Object, mapperMock.Object);
//Act
var action = await controller.DeleteMessage(1, 1, "test") as NotFoundObjectResult;
//Assert
Assert.Equal(404, action.StatusCode);
Assert.NotNull(action.Value);
}
public async void DeleteMessageThrowsException()
{
// Arrange
var mock = new Mock <IMessageRepository>();
mock.SetupSequence(rep => rep.GetMessageByIdAsync(It.IsAny <int>())).Throws <MessagesDomainException>();
MessageController controller = new MessageController(mock.Object);
// Act & Assert
Exception ex = await Assert.ThrowsAsync <MessagesDomainException>(
async() => await controller.DeleteMessage(int.MaxValue)
);
Assert.Equal(typeof(MessagesDomainException), ex.GetType());
}
public async void DeleteMessageNoContent(Message[] messages)
{
// Arrange
var mock = new Mock <IMessageRepository>();
Message messageDeleted = messages[0];
mock.SetupSequence(rep => rep.GetMessageByIdAsync(messageDeleted.Id)).Returns(Task <Message> .Run(() => messageDeleted));
MessageController controller = new MessageController(mock.Object);
// Act
NoContentResult model = await controller.DeleteMessage(messageDeleted.Id) as NoContentResult;
// Assert
mock.Verify(rep => rep.RemoveMessageAsync(It.IsAny <int>()), Times.Once);
Assert.Equal((int?)HttpStatusCode.NoContent, model.StatusCode);
}
public async Task DeleteMessage_ShouldReturnNotFoundResult_WhenMessageDoesNotExist()
{
// Arrange
const int messageId = 641;
_mediatorMock
.Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
MessageController controller = new MessageController(null, _mediatorMock.Object);
// Act
ActionResult response = await controller.DeleteMessage(messageId);
// Assert
NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response);
ErrorResource error = Assert.IsType <ErrorResource>(result.Value);
Assert.NotNull(error);
Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode);
}
public async Task DeleteMessageNoContentStatusSenderDelete()
{
//Arrange
Message message = new Message {
MessageId = 1, RecipientDeleted = false, SenderDeleted = false
};
wrapperMock.Setup(m => m.MessageRepository.GetMessage(1)).Returns(Task.Run(() =>
{
return(message);
}));
MessageController controller = new MessageController(wrapperMock.Object, mapperMock.Object);
//Act
var action = await controller.DeleteMessage(1, 1, "sender") as NoContentResult;
//Assert
Assert.Equal(204, action.StatusCode);
Assert.False(message.RecipientDeleted);
Assert.True(message.SenderDeleted);
}
private void OnDeleteButtonPressed(string id)
{
MessageController.DeleteMessage(id);
SceneManager.LoadScene("MessagesView");
}
public void ReturnNoContentWhenDeleteMessageCalled()
{
IActionResult result = _controller.DeleteMessage(1);
Assert.IsType <NoContentResult>(result);
}
