public async Task LoginCommandHandler_ShouldReturnNull_WhenPasswordIsInvalid()
{
// Arrange
LoginCommand request = new()
{
UserNameOrEmail = "*****@*****.**",
Password = "******"
};
_unitOfWorkMock
.Setup(m => m.Users.GetByUserNameOrEmail(It.IsAny <string>()))
.ReturnsAsync(new User());
_cryptoServiceMock
.Setup(m => m.VerifyPassword(It.IsAny <byte[]>(), It.IsAny <byte[]>(), It.IsAny <string>()))
.Returns(false);
LoginCommand.Handler handler = new(_unitOfWorkMock.Object, null, _cryptoServiceMock.Object);
// Act
AuthenticatedUserResource user = await handler.Handle(request);
// Assert
Assert.Null(user);
}
public async Task LoginCommandHandler_ShouldReturnNull_WhenPasswordIsInvalid()
{
// Arrange
IEnumerable <User> expectedUser = new [] { new User() };
LoginCommand request = new LoginCommand
{
UserNameOrEmail = "*****@*****.**",
Password = "******"
};
IQueryable <User> userQueryableMock = expectedUser
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.Users.GetByUserNameOrEmail(It.IsAny <string>()))
.Returns(userQueryableMock);
_cryptoServiceMock
.Setup(m => m.VerifyPassword(It.IsAny <byte[]>(), It.IsAny <byte[]>(), It.IsAny <string>()))
.Returns(false);
LoginCommand.Handler handler = new LoginCommand.Handler(_unitOfWorkMock.Object, null, _cryptoServiceMock.Object);
// Act
AuthenticatedUserResource user = await handler.Handle(request);
// Assert
Assert.Null(user);
}
public async Task LoginCommandHandler_ShouldReturnNull_WhenUserNameOrEmailAreInvalid()
{
// Arrange
IEnumerable <User> expectedUser = new User[] { };
LoginCommand request = new LoginCommand
{
UserNameOrEmail = "*****@*****.**"
};
Mock <IQueryable <User> > userQueryableMock = expectedUser
.AsQueryable()
.BuildMock();
_unitOfWorkMock
.Setup(m => m.Users.GetByUserNameOrEmail(It.IsAny <string>()))
.Returns(userQueryableMock.Object);
LoginCommand.Handler handler = new LoginCommand.Handler(_unitOfWorkMock.Object, null, null);
// Act
AuthenticatedUserResource user = await handler.Handle(request);
// Assert
Assert.Null(user);
}
public async Task AuthenticateQueryHandler_ShouldReturnNull_WhenNameIdentifierClaimIsInvalid()
{
// Arrange
const string expectedToken = "some.access.token";
Claim expectedNameIdentifierClaim = new(ClaimTypes.NameIdentifier, "8979");
IHeaderDictionary headers = new HeaderDictionary
{
{ "Authorization", expectedToken }
};
_httpContextAccessorMock
.Setup(m => m.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier))
.Returns(expectedNameIdentifierClaim);
_httpContextAccessorMock
.Setup(m => m.HttpContext.Request.Headers)
.Returns(headers);
_unitOfWorkMock
.Setup(m => m.Users.GetByIdAsync(It.IsAny <int>()))
.ReturnsAsync(null as User);
AuthenticateQuery.Handler handler =
new(_unitOfWorkMock.Object, _mapperMock, _httpContextAccessorMock.Object, _userProviderMock.Object);
// Act
AuthenticatedUserResource user = await handler.Handle(new AuthenticateQuery());
// Assert
Assert.Null(user);
}
public async Task AuthenticateQueryHandler_ShouldReturnUser_WhenTokenIsValid()
{
// Arrange
const string expectedToken = "some.access.token";
IHeaderDictionary headers = new HeaderDictionary
{
{ "Authorization", expectedToken }
};
User expectedUser = new() { UserId = 1 };
_httpContextAccessorMock
.Setup(m => m.HttpContext.Request.Headers)
.Returns(headers);
_unitOfWorkMock
.Setup(m => m.Users.GetByIdAsync(It.IsAny <int>()))
.ReturnsAsync(expectedUser);
AuthenticateQuery.Handler handler =
new(_unitOfWorkMock.Object, _mapperMock, _httpContextAccessorMock.Object, _userProviderMock.Object);
// Act
AuthenticatedUserResource user = await handler.Handle(new AuthenticateQuery());
// Assert
Assert.NotNull(user);
Assert.Equal(1, user.UserId);
Assert.Equal(expectedToken, user.Token);
}
public async Task Authenticate_ShouldReturnUser_WhenAuthenticationWasSuccessful()
{
// Arrange
AuthenticatedUserResource expectedUser = new AuthenticatedUserResource()
{
UserId = 1
};
_mediatorMock
.Setup(m => m.Send(It.IsAny <AuthenticateQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedUser);
UserController controller = new UserController(_mediatorMock.Object, null);
// Act
ActionResult <AuthenticatedUserResource> response = await controller.Authenticate();
// Assert
OkObjectResult okResult = Assert.IsType <OkObjectResult>(response.Result);
AuthenticatedUserResource actualUser = (AuthenticatedUserResource)okResult.Value;
Assert.NotNull(actualUser);
Assert.Equal(expectedUser.UserId, actualUser.UserId);
}
public async Task <ActionResult <AuthenticatedUserResource> > Authenticate(CancellationToken cancellationToken = default)
{
AuthenticateQuery query = new AuthenticateQuery();
AuthenticatedUserResource user = await _mediator.Send(query, cancellationToken);
return(Ok(user));
}
public async Task LoginCommandHandler_ShouldReturnUser_WhenCredentialsAreCorrect()
{
// Arrange
const string expectedToken = "some.access.token";
IEnumerable <User> expectedUser = new[]
{
new User {
UserId = 1
}
};
LoginCommand request = new LoginCommand
{
UserNameOrEmail = "*****@*****.**",
Password = "******"
};
IQueryable <User> userQueryableMock = expectedUser
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.Users.GetByUserNameOrEmail(It.IsAny <string>()))
.Returns(userQueryableMock);
_cryptoServiceMock
.Setup(m => m.VerifyPassword(It.IsAny <byte[]>(), It.IsAny <byte[]>(), It.IsAny <string>()))
.Returns(true);
_cryptoServiceMock
.Setup(m => m.GenerateToken(It.IsAny <User>()))
.Returns(expectedToken);
LoginCommand.Handler handler = new LoginCommand.Handler(_unitOfWorkMock.Object, _mapperMock, _cryptoServiceMock.Object);
// Act
AuthenticatedUserResource user = await handler.Handle(request);
// Assert
Assert.NotNull(user);
Assert.Equal(1, user.UserId);
Assert.Equal(expectedToken, user.Token);
}
public async Task LoginCommandHandler_ShouldReturnNull_WhenUserNameOrEmailAreInvalid()
{
// Arrange
LoginCommand request = new()
{
UserNameOrEmail = "*****@*****.**"
};
_unitOfWorkMock
.Setup(m => m.Users.GetByUserNameOrEmail(It.IsAny <string>()))
.ReturnsAsync(null as User);
LoginCommand.Handler handler = new(_unitOfWorkMock.Object, null, null);
// Act
AuthenticatedUserResource user = await handler.Handle(request);
// Assert
Assert.Null(user);
}
public async Task Login_ShouldReturnUser_WhenCredentialsAreValid()
{
// Arrange
AuthenticatedUserResource expectedUser = new AuthenticatedUserResource()
{
UserId = 1
};
LoginBody credentials = new LoginBody
{
UserNameOrEmail = "myUsername",
Password = "******"
};
Mock <IMediator> mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(m => m.Send(It.IsAny <LoginCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedUser);
MapperConfiguration mapperConfiguration = new MapperConfiguration(config =>
{
config.CreateMap <LoginBody, LoginCommand>();
});
IMapper mapperMock = mapperConfiguration.CreateMapper();
SessionController controller = new SessionController(mediatorMock.Object, mapperMock);
// Act
ActionResult <AuthenticatedUserResource> response = await controller.Login(credentials);
// Assert
OkObjectResult okResult = Assert.IsType <OkObjectResult>(response.Result);
AuthenticatedUserResource actualUser = (AuthenticatedUserResource)okResult.Value;
Assert.NotNull(actualUser);
Assert.Equal(expectedUser.UserId, actualUser.UserId);
}
public async Task <ActionResult <AuthenticatedUserResource> > Login([FromBody] LoginBody credentials, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
LoginCommand command = _mapper.Map <LoginBody, LoginCommand>(credentials);
AuthenticatedUserResource user = await _mediator.Send(command, cancellationToken);
if (user == null)
{
return(Unauthorized(new ErrorResource
{
StatusCode = StatusCodes.Status401Unauthorized,
Message = "UserName, e-mail and/or password are incorrect"
}));
}
return(Ok(user));
}
