public async void Cant_Login_When_Unknown_Account()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository
.Setup(repo => repo.FindByName(It.IsAny <string>()))
.Returns(Task.FromResult <User>(null));
mockUserRepository
.Setup(repo => repo.CheckPassword(It.IsAny <User>(), It.IsAny <string>()))
.Returns(Task.FromResult(true));
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory
.Setup(repo => repo.GenerateEncodedToken(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(new Token("", "", 0)));
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
// act
var response = await useCase.Handle(new LoginRequest("", "password"), mockOutputPort.Object);
// assert
Assert.False(response);
}
public async void Handle_GivenValidCredentials_ShouldSucceed()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(repo => repo.FindByName(It.IsAny <string>())).ReturnsAsync(new User("", "", "", ""));
mockUserRepository.Setup(repo => repo.CheckPassword(It.IsAny <User>(), It.IsAny <string>())).ReturnsAsync(true);
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory.Setup(factory => factory.GenerateEncodedToken(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(new AccessToken("", 0));
var mockTokenFactory = new Mock <ITokenFactory>();
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object, mockTokenFactory.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
// act
var response = await useCase.Handle(new LoginRequest("userName", "password", "127.0.0.1"), mockOutputPort.Object);
// assert
Assert.True(response);
}
public async void Handle_GivenUnknownCredentials_ShouldReturnFalse()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(repo => repo.FindByName(It.IsAny <string>())).Returns(Task.FromResult <User>(null));
mockUserRepository.Setup(repo => repo.CheckPassword(It.IsAny <User>(), It.IsAny <string>())).Returns(Task.FromResult(true));
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory.Setup(factory => factory.GenerateEncodedToken(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(new AccessToken("", 0)));
var mockTokenFactory = new Mock <ITokenFactory>();
mockTokenFactory.Verify(factory => factory.GenerateToken(32), Times.Never);
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object, mockTokenFactory.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
// act
var response = await useCase.Handle(new LoginRequest("", "password", "127.0.0.1"), mockOutputPort.Object);
// assert
Assert.False(response);
}
public async void Handle_GivenIncompleteCredentials_ShouldFail()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(repo => repo.FindUserByName(It.IsAny <string>())).ReturnsAsync(new User("", "", "", ""));
mockUserRepository.Setup(repo => repo.CheckPassword(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(new LogInResponse(null, false));
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory.Setup(factory => factory.GenerateEncodedToken(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(new AccessToken("", 0));
var mockTokenFactory = new Mock <ITokenFactory>();
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object, mockTokenFactory.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
// act
var response = await useCase.Handle(new LoginRequest("", "password", "127.0.0.1"), mockOutputPort.Object);
// assert
Assert.False(response);
mockUserRepository.Verify(factory => factory.CheckPassword(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
mockUserRepository.Verify(factory => factory.SignIn(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>()), Times.Never);
mockTokenFactory.Verify(factory => factory.GenerateToken(32), Times.Never);
mockUserRepository.Verify(factory => factory.FindByName(""), Times.Never);
mockOutputPort.VerifyAll();
mockTokenFactory.VerifyAll();
mockJwtFactory.Verify(factory => factory.GenerateEncodedToken(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public async void Cant_Login_When_Password_Is_Missing()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository
.Setup(repo => repo.GetByName(It.IsAny <string>()))
.Returns(Task.FromResult(new User("", "")));
mockUserRepository
.Setup(repo => repo.CheckPassword(It.IsAny <User>(), It.IsAny <string>()))
.Returns(await Task.FromResult(true));
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory
.Setup(repo => repo.GenerateToken(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(await Task.FromResult(new Token("", "", 0, "")));
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
// act
var response = await useCase.Handle(new LoginRequest("username", ""), mockOutputPort.Object);
// assert
Assert.False(response);
}
public async void Handle_GivenUnknownCredentials_Fails()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(repo => repo.FindByNameAsync(It.IsAny <string>())).ReturnsAsync((ACSUser?)null);
mockUserRepository.Setup(repo => repo.CheckPasswordAsync(It.IsAny <ACSUser>(), It.IsAny <string>())).ReturnsAsync(true);
var tokenServiceMock = new Mock <ITokenService>();
tokenServiceMock.Setup(factory => factory.GenerateEncodedToken(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>())).Returns(new AccessToken("", 0, ""));
var useCase = new LoginUseCase(mockUserRepository.Object, tokenServiceMock.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
// act
var response = await useCase.Handle(new LoginRequest("", "password", "127.0.0.1"), mockOutputPort.Object);
// assert
Assert.False(response);
tokenServiceMock.Verify(factory => factory.GenerateToken(32), Times.Never);
}
public async void Cant_Login_When_Missing_Username()
{
// Arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(_ => _.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(new User("", "", "", ""));
mockUserRepository.Setup(_ => _.CheckPasswordAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory.Setup(_ => _.GenerateEncodedToken(It.IsAny <string>()))
.ReturnsAsync(new Token("", "", 0));
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object);
var mockOutput = new Mock <IOutputPort <LoginResponse> >();
mockOutput.Setup(_ => _.Handle(It.IsAny <LoginResponse>()));
//Act
var response = await useCase.Handle(new LoginRequest("", ""), mockOutput.Object);
//Assert
Assert.False(response);
}
public async Task <IActionResult> Login([FromForm] AccountLoginViewModel model,
[FromServices] SignInManager <User> signInManager, CancellationToken token)
{
if (!ModelState.IsValid)
{
return(View(model));
}
return(await InvokeMediator(LoginUseCase.Publish(model.Login, model.Password),
token, forbiddenResultFactoryAsync : async(_, _) =>
{
var result = await signInManager.PasswordSignInAsync(model.Login, model.Password, true, false);
if (result.IsLockedOut)
{
ModelState.AddModelError(string.Empty, "Sorry but your account is locked out.");
}
if (result.IsNotAllowed)
{
ModelState.AddModelError(string.Empty,
"Sorry but that login type is not allowed for your account.");
}
return View(model);
}, successResultFactoryAsync : async(response, _) =>
{
var user = response.Result;
var result = await signInManager.PasswordSignInAsync(user, model.Password, true, false);
if (result.Succeeded)
{
return Redirect(model.ReturnUrl ?? "/");
}
throw new ApplicationException(result.ToString());
}));
}
public async Task UserLogin()
{
Logins l = new Logins()
{
user_id = 1, login_time = DateTime.Now.ToString("yyyy-MM-dd HH:mm")
};
UseCaseBase loginUseCase = new LoginUseCase(l);
loginUseCase.SetCallBack(this);
await loginUseCase.Execute();
}
public IHttpActionResult LoginPos(LoginDto loginData)
{
try{
var login = LoginUseCase.CreateLogin(loginData.Username, loginData.Password);
login.StartSession();
return(Ok(GetSessionLogged(login)));
}
catch (Exception ex) {
return(BadRequest(ex.Message));
}
}
public async Task LoginUseCaseNotNullInput()
{
var output = new Mock <LoginPresenter>().Object;
var useCase = new LoginUseCase(
userRepository,
output,
authService);
await useCase.Execute(new LoginInput("", ""));
Assert.NotNull(output);
Assert.True(output.ViewModel is NotFoundObjectResult);
}
private SessionDto GetSessionLogged(LoginUseCase login)
{
var sesion = new SessionDto();
var employee = login.EmployeeLogged;
sesion.ClientId = employee.EmployeeId;
sesion.UserId = employee.Credentials.UserId;
sesion.Username = employee.Credentials.Username;
sesion.FullName = employee.ToString();
sesion.Email = employee.Credentials.Email;
sesion.ProfileId = employee.Profile.ProfileId;
sesion.ProfileName = employee.Profile.ProfileName;
return(sesion);
}
private IUseCase <LoginRequestEvent, LoginResponseEvent> SetupMock()
{
mock = new Mock <AccountRepository>(null);
mock.Setup(x => x.Accounts).Returns(new Account[]
{
new Account {
Id = 1,
Login = "******",
Password = "******",
FirstName = "FirstName1",
LastName = "LastName1",
Email = "*****@*****.**",
Phone = "380694512356",
Skype = "login1",
Type = AccountType.Employee
},
new Account {
Id = 2,
Login = "******",
Password = "******",
FirstName = "FirstName2",
LastName = "LastName2",
Email = "*****@*****.**",
Phone = "380694512352",
Skype = "login2",
Type = AccountType.Employee
},
new Account {
Id = 3,
Login = "******",
Password = "******",
FirstName = "FirstName3",
LastName = "LastName3",
Email = "*****@*****.**",
Phone = "380694512353",
Skype = "login3",
Type = AccountType.Employee
}
});
IValidationActivity <LoginRequestEvent> validationActivity = new LoginValidationActivity(new LoginOperationValidationRule());
IRequestActivity <LoginRequestEvent, LoginResponseEvent> request = new GetAccountByRequest(mock.Object);
IUseCase <LoginRequestEvent, LoginResponseEvent> loginUseCase = new LoginUseCase(validationActivity, request);
return(loginUseCase);
}
private void StartSession()
{
try{
var user = Credential.CreateCredential();
user.Username = UsernameTextBox.Text;
user.Password = PasswordTextBox.Text;
user.EncriptedPassword = user.EncryptPassword();
var login = LoginUseCase.CreateLogin(user.Username, user.EncriptedPassword);
login.StartSession();
ActualUser.ActualEmployee = login.EmployeeLogged;
OpenForm();
}
catch (Exception ex) {
MessageBox.Show(ex.Message, "Atención", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
PasswordTextBox.Text = string.Empty;
UsernameTextBox.Focus();
}
}
public async void Cant_Login_When_Password_Incorrect()
{
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository
.Setup(repo => repo.FindByName(It.IsAny <string>()))
.Returns(Task.FromResult(new User(It.IsAny <string>())));
mockUserRepository
.Setup(repo => repo.SignIn(It.IsAny <User>(), It.IsAny <string>()))
.Returns(Task.FromResult(false));
var useCase = new LoginUseCase(mockUserRepository.Object);
var mockOutputPort = new Mock <IOutputPort <LoginResponse> >();
mockOutputPort.Setup(outputPort => outputPort.Handle(It.IsAny <LoginResponse>()));
var response = await useCase.Handle(new LoginRequest("userName", "password"), mockOutputPort.Object);
Assert.False(response);
}
public async void Handle_GivenInvalidPassword_ShouldFail()
{
// arrange
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(repo => repo.FindByName(It.IsAny <string>())).ReturnsAsync((User)null);
mockUserRepository.Setup(repo => repo.CheckPassword(It.IsAny <User>(), It.IsAny <string>())).ReturnsAsync(false);
var mockJwtFactory = new Mock <IJwtFactory>();
mockJwtFactory.Setup(factory => factory.GenerateEncodedToken(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync("");
var mockTokenFactory = new Mock <ITokenFactory>();
var useCase = new LoginUseCase(mockUserRepository.Object, mockJwtFactory.Object, mockTokenFactory.Object);
// act
await useCase.Handle(new LoginRequest("", "password", "127.0.0.1"));
// assert
Assert.True(useCase.HasError);
mockTokenFactory.Verify(factory => factory.GenerateToken(32), Times.Never);
}
