public async Task <DeleteUserByIdResponse> Handle(DeleteUserByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetUserQuery()
{
Id = request.Id
};
var id = await queryExecutor.Execute(query);
if (id == null)
{
return(new DeleteUserByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var user = this.mapper.Map <User>(request);
var command = new DeleteUserByIdCommand()
{
Parameter = user
};
var userFromDB = await this.commandExecutor.Execute(command);
return(new DeleteUserByIdResponse()
{
Data = userFromDB
});
}
public void DeleteUserByIdCommand_FailUserNotExist()
{
var command = new DeleteUserByIdCommand(new Guid("f5d958ec-d760-4abe-bf3e-c8ba12c975e6"));
base.UsersRespositoryMock.Setup(user => user.FindSingle(It.IsAny <Expression <Func <User, bool> > >()));
var validator = new DeleteUserByIdCommandValidator(UnitOfWorkMock.Object);
var result = validator.Validate(command);
Assert.IsFalse(result.IsValid);
}
public void DeleteUserByIdCommand_FailEmtpyId()
{
var command = new DeleteUserByIdCommand(new Guid());
base.UsersRespositoryMock.Setup(user => user.FindSingle(It.IsAny <Expression <Func <User, bool> > >())).ReturnsAsync(User);
var validator = new DeleteUserByIdCommandValidator(UnitOfWorkMock.Object);
var result = validator.Validate(command);
Assert.IsFalse(result.IsValid);
}
public void DeleteUserByIdTest()
{
PostUserCommand postUserCommand = new PostUserCommand(_user);
postUserCommand.Execute();
var user = postUserCommand.GetResult();
DeleteUserByIdCommand deleteUserByIdCommand = new DeleteUserByIdCommand(user.Id);
deleteUserByIdCommand.Execute();
var id = deleteUserByIdCommand.GetResult();
Assert.AreEqual(id, user.Id);
}
public async Task <Response <bool> > Handle(DeleteUserByIdCommand request, CancellationToken cancellationToken)
{
var user = await _unitOfWork.Users.FindSingle(x => x.Id == request.Id);
if (user == null)
{
return(Response.Fail404NotFound <bool>("User Not Found"));
}
await _unitOfWork.Users.Remove(us => us.Id == request.Id);
return(Response.Ok200 <bool>(true));
}
public async Task GivenAnId_WhenDeleteUserByIdCommandHandler_ThenReturnTrue()
{
var user = UserFactory.ValidUser();
var command = new DeleteUserByIdCommand(user.Id);
var mockRepo = new Mock <IUserRepository>();
mockRepo.Setup(db => db.DeleteAsync(command.Id).Result).Returns(true);
var handler = new DeleteUserByIdCommandHandler(mockRepo.Object);
var result = await handler.Handle(command, CancellationToken.None);
result.Should().BeTrue();
}
public async Task <IdResponse> HandleAsync(DeleteUserByIdCommand cmd, CancellationToken ct)
{
if (cmd.Id.Equals(Guid.Empty))
{
return(IdResponse.Unsuccessful("Id is empty"));
}
var user = await _userRepository.GetByIdAsync(cmd.Id);
var result = await _userRepository.DeleteByTAsync(user);
return(IdResponse.Successful(user.Id));
}
public async void Task_Delete_Depense_Return_NotFoundResult()
{
//Arrange
var command = new DeleteUserByIdCommand()
{
Id = 1
};
mediator.Setup(m => m.Send(It.IsAny <DeleteUserByIdCommand>(), CancellationToken.None)).Returns(Task.FromResult(0));
var controller = new UsersController(mediator.Object);
//Act
var data = await controller.Delete(1);
//Assert
Assert.IsType <NotFoundResult>(data);
}
public ActionResult <int> Delete(int id)
{
try
{
// _logger.LogInformation("Ejecutando Comando DeleteUserByIdCommand(id)", id);
DeleteUserByIdCommand command = new DeleteUserByIdCommand(id);
command.Execute();
// _logger.LogInformation("Ejecutado Comando DeleteUserByIdCommand(id)", id);
}
catch (GeneralException e)
{
// _logger.LogWarning("Exception", e);
return(BadRequest(e.Message));
}
catch (Exception ex)
{
// _logger.LogError("BadRequest: ", ex);
return(BadRequest("Error eliminando al usuario"));
}
return(Ok());
}
public IHttpActionResult DeleteUser([FromUri] DeleteUserByIdCommand command)
{
var response = _mediator.Request(command);
return(Ok(response.Data));
}
