public async Task Handle_ValidAccount_HappyFlow()
{
// Arrange
LoginCommand request = new LoginCommand
{
Email = ConstantsAccountsCQTest.Email,
Password = ConstantsAccountsCQTest.Password
};
_accountRepositoryMock.Setup(x => x.ExistsAccount(request.Email, request.Password)).Returns(true);
_accountRepositoryMock.Setup(x => x.GetAccount(request.Email, request.Password)).Returns(ConstantsAccountsCQTest.AccountTest);
_userStatusVerificationMock.Setup(x => x.UserIsActive(ConstantsAccountsCQTest.AccountTest.Id)).Returns(Results.Ok());
_tokenCreatorMock.Setup(x => x.CreateToken(ConstantsAccountsCQTest.AccountTest)).Returns(ConstantsAccountsCQTest.Token2);
_accountRepositoryMock.Setup(x => x.SaveModifications()).Returns(Results.Ok());
// Act
Result <PortalAccount> result = await _handler.Handle(request, CancellationToken.None);
// Assert
result.IsSuccess.Should().BeTrue();
result.Value.Should().BeEquivalentTo(new PortalAccount {
Token = ConstantsAccountsCQTest.Token2, Username = ConstantsAccountsCQTest.AccountTest.Username
});
_accountRepositoryMock.Verify(x => x.SaveModifications(), Times.Once());
ConstantsAccountsCQTest.AccountTest.Token.Should().Be(ConstantsAccountsCQTest.Token2);
ConstantsAccountsCQTest.AccountTest.LastLogintime.Should().BeAfter(DateTime.MinValue);
ConstantsAccountsCQTest.AccountTest.LastLogintime.Should().BeAfter(DateTime.UtcNow.AddMinutes(-1));
ConstantsAccountsCQTest.AccountTest.LastLogintime.Should().BeBefore(DateTime.UtcNow);
}
public void ShouldReturnToken()
{
var command = new LoginCommand()
{
Email = "*****@*****.**",
Password = "******"
};
_loginCommandHandler.Handle(command);
Assert.IsFalse(string.IsNullOrEmpty(command.Token));
}
public async Task Handle_Should_ReturnErrorIfUserNotFound()
{
_emailValidatorMock.Setup(m => m.Validate(It.IsAny <string>()))
.Returns(true);
var command = new LoginCommand("*****@*****.**", "password");
var result = await _handler.Handle(command, GetCancellationToken());
result.Should().NotBeNull();
result.Value.Should().BeNull();
result.ErrorMessages.Should().Contain(LoginCommandHandler.Email_Or_Password_Not_Correct);
}
public async Task SuccessfulLogin()
{
// Arrange
_command.Email = "*****@*****.**";
_command.Password = "******";
var fakeStaff = Mock.Of <Staff>();
fakeStaff.Id = 123;
fakeStaff.Name = "FakeName";
fakeStaff.Role = Role.LIBRARYASSISTANT;
_staffRepo.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(fakeStaff);
_passwordHelper.Setup(x => x.ValidatePassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
_signInManager.Setup(x => x.SignInAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <bool>())).Returns(Task.FromResult(0));
var cacheEntry = Mock.Of <ICacheEntry>();
_memoryCache
.Setup(m => m.CreateEntry(It.IsAny <object>()))
.Returns(cacheEntry);
var sut = new LoginCommandHandler(_signInManager.Object, _passwordHelper.Object, _memoryCache.Object, _staffRepo.Object);
// Act
var result = await sut.Handle(_command, default);
// Assert
Assert.True(result);
}
public async Task Handle_ValidCommand_ShouldLoginSuccessfully(LoginOutput loginOutput)
{
// Arrange
_mapperMock.Setup(m => m.Map <LoginOutput>(It.IsAny <User>())).Returns(loginOutput); // AutoMapper setup
_appsettingMock.SetReturnsDefault(new AppSettings
{
Issuer = "key1",
Secret = "kesdfaaaaaasffffffffy1"
});
var sut = new LoginCommandHandler(_context, _mapperMock.Object, _appsettingMock.Object); // creating system under test
var temUser = _fixture.Create <User>();
temUser.PasswordHash = "3pRTT3NlZJrki0wrSlmOjA==";
// Act
await ContextOperation.CreateEntity(_context, temUser);
var password = SecurityHelper.Decrypt(temUser.PasswordHash);
var output = await sut.Handle(new LoginCommand { Email = temUser.Email, Password = password }, CancellationToken.None);
// Assert
Assert.True(!string.IsNullOrEmpty(output.Token));
}
// Command Handling
#region Command Handling
public CommandStatus Handle(LoginCommand command)
{
ICollectionRead <Usuario> cmdData = new UsuarioData();
LoginCommandHandler cmdHandler = new LoginCommandHandler(cmdData);
return(cmdHandler.Handle(command));
}
public async Task Login_User_ShouldReturnBadRequestException(string exceptionMessage)
{
// Arrange
var expectedUsers = new UserModel[] { new UserModel {
Username = "******", Password = "******"
} };
var mock = expectedUsers.AsQueryable().BuildMock();
Mock <IRepository <UserModel> > userRepo = new Mock <IRepository <UserModel> >();
userRepo.Setup(repo => repo.FindAll()).Returns(mock.Object);
userRepo.Setup(repo => repo.Find(It.IsAny <Expression <Func <UserModel, bool> > >()))
.Returns(new UserModel[] { }.AsQueryable().BuildMock().Object);
Mock <IOptions <JwtOptions> > config = new Mock <IOptions <JwtOptions> >();
config.Setup(x => x.Value).Returns(new JwtOptions {
Key = "testKey12312_woeifo23423",
Issuer = "http://localhost:5000"
});
var handler = new LoginCommandHandler(config.Object, userRepo.Object);
// Act
var ex = await Assert.ThrowsAsync <BadRequestException>(() => handler.Handle(new LoginCommand {
Username = "******",
Password = "******"
}, It.IsAny <CancellationToken>()));
// Assert
ex.Message.Should().Be(string.Format(exceptionMessage, "testUsername"));
}
public async Task Login_User_ShouldReturnToken()
{
// Arrange
var expectedUsers = new UserModel[] { new UserModel {
Username = "******", Password = "******"
} };
var mock = expectedUsers.AsQueryable().BuildMock();
Mock <IRepository <UserModel> > userRepo = new Mock <IRepository <UserModel> >();
userRepo.Setup(repo => repo.FindAll()).Returns(mock.Object);
userRepo.Setup(repo => repo.Find(It.IsAny <Expression <Func <UserModel, bool> > >()))
.Returns(mock.Object);
Mock <IOptions <JwtOptions> > config = new Mock <IOptions <JwtOptions> >();
config.Setup(x => x.Value).Returns(new JwtOptions {
Key = "testKey12312_woeifo23423",
Issuer = "http://localhost:5000"
});
var handler = new LoginCommandHandler(config.Object, userRepo.Object);
// Act
await handler.Handle(new LoginCommand {
Username = "******",
Password = "******"
}, It.IsAny <CancellationToken>());
// Assert
userRepo.Verify(x => x.Find(It.IsAny <Expression <Func <UserModel, bool> > >()), Times.Once);
}
public async Task RejectsOnNOnExistingEmail()
{
_command.Email = "*****@*****.**";
_command.Password = "******";
var sut = new LoginCommandHandler(_signInManager.Object, _passwordHelper.Object, _memoryCache.Object, _staffRepo.Object);
var result = await sut.Handle(_command, default);
Assert.False(result);
}
public async Task LoginCommandHandler_ShouldReturn_LoginCommandResult()
{
// var mockIHttpClientFactory = Substitute.For<IHttpClientFactory>();
var messageHandler = new MockHttpMessageHandler("As per our requirement we mock string!", HttpStatusCode.OK);
var httpClient = new HttpClient(messageHandler);
httpClient.BaseAddress = new Uri("https://www.google.com");
var handler = new LoginCommandHandler(httpClient);
var result = await handler.Handle(new LoginCommand(), new CancellationToken());
Assert.NotNull(result);
}
// Command Handling
public void In_LoginCommand(LoginCommand command)
{
try
{
ICollectionRead <Usuario> cmdData = new UsuarioData();
LoginCommandHandler cmdHandler = new LoginCommandHandler(cmdData);
Out_LoginCommandResult(cmdHandler.Handle(command));
}
catch (Exception)
{
throw;
}
}
public async void LoginCommand_CanLoginWithValidCredentials(string username, string password)
{
var expectedId = 1;
Context.Shops.Add(new Shop()
{
Id = expectedId,
MemberAreaUsername = username,
MemberAreaPassword = HasherServiceMock.GetHash(password),
Administrator = true,
});
Context.SaveChanges();
var command = new LoginCommand()
{
UserName = username,
Password = password,
};
var actualId = await _handler.Handle(command, CancellationToken.None);
Assert.Equal(expectedId, actualId);
}
public async Task RejectsOnWrongPassword()
{
_command.Email = "*****@*****.**";
_command.Password = "******";
_staffRepo.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(new Staff());
_passwordHelper.Setup(x => x.ValidatePassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(false);
var sut = new LoginCommandHandler(_signInManager.Object, _passwordHelper.Object, _memoryCache.Object, _staffRepo.Object);
var result = await sut.Handle(_command, default);
Assert.False(result);
}
public async Task Should_ThrowException_When_InputIsNull()
{
// Arrange
var userStore = new Mock <IUserStore <User> >();
userStore.Setup(x => x.FindByIdAsync("123", CancellationToken.None))
.ReturnsAsync(new User()
{
UserName = "******",
Id = 123
});
var userManager = new UserManager <User>(userStore.Object, null, null, null, null, null, null, null, null);
var jwtService = new Mock <IJwtService>();
// Act
var commandHandler = new LoginCommandHandler(userManager, jwtService.Object);
// Assert
await Assert.ThrowsAsync <InvalidNullInputException>(() => commandHandler.Handle(null, CancellationToken.None));
}
public async Task Handle_InValidCommand_ShouldLoginWithError(LoginOutput loginOutput)
{
// Arrange
_mapperMock.Setup(m => m.Map <LoginOutput>(It.IsAny <User>())).Returns(loginOutput); // AutoMapper setup
_appsettingMock.SetReturnsDefault(new AppSettings
{
Issuer = "key1",
Secret = "kesdfaaaaaasffffffffy1"
});
var sut = new LoginCommandHandler(_context, _mapperMock.Object, _appsettingMock.Object); // creating system under test
var temUser = _fixture.Create <User>();
// Act
// Assert
await Assert.ThrowsAsync <NotFoundException>(() => sut.Handle(new LoginCommand {
Email = _fixture.Create <string>(), Password = _fixture.Create <string>()
}, CancellationToken.None));
}
async Task WhenHandlerHandlesTheCommand()
{
_result = await _sut.Handle(_command);
}
