public async Task Login()
{
var salt = Guid.NewGuid().ToByteArray();
var person = new User
{
Name = "username",
Email = "email",
Hash = new PasswordHasher().Hash("password", salt),
Salt = salt
};
await InsertAsync(person);
var command = new Login.Command
{
User = new Login.UserData
{
Email = "email",
Password = "******"
}
};
var user = await SendAsync(command);
user.Should().NotBeNull();
user.User.Should().NotBeNull();
user.User.Email.Should().BeEquivalentTo(command.User.Email);
user.User.Name.Should().BeEquivalentTo("username");
user.User.Token.Should().NotBeEmpty();
}
public async Task Expect_Login()
{
var salt = Guid.NewGuid().ToByteArray();
const string password = "******";
const string email = "*****@*****.**";
const string username = "******";
var person = new Person
{
Username = username,
Email = email,
Hash = new PasswordHasher().Hash(password, salt),
Salt = salt
};
await InsertAsync(person);
var command = new Login.Command
{
User = new Login.UserData
{
Email = email,
Password = password
}
};
var user = await SendAsync(command);
Assert.NotNull(user?.User);
Assert.Equal(user.User.Email, command.User.Email);
Assert.Equal(username, user.User.Username);
Assert.NotNull(user.User.Token);
Console.WriteLine(user.User.Token);
}
public async Task Expect_Login()
{
var salt = Guid.NewGuid().ToByteArray();
var customer = new Customer
{
Email = "*****@*****.**",
Hash = new PasswordHasher().Hash("hunter2", salt),
Salt = salt
};
await InsertAsync(customer);
var command = new Login.Command()
{
User = new Login.UserData()
{
Email = "*****@*****.**",
Password = "******"
}
};
var user = await SendAsync(command);
Assert.NotNull(user?.User);
Assert.Equal(user.User.Email, command.User.Email);
Assert.NotNull(user.User.Token);
}
public async Task Expect_RestException_On_Invalid_Credentials(
string email, string password, string loginEmail, string loginPassword)
{
var salt = Guid.NewGuid().ToByteArray();
const string username = "******";
var person = new Person
{
Username = username,
Email = email,
Hash = new PasswordHasher().Hash(password, salt),
Salt = salt
};
await InsertAsync(person);
var command = new Login.Command
{
User = new Login.UserData
{
Email = loginEmail,
Password = loginPassword
}
};
RestException ex = await Assert.ThrowsAsync <RestException>(async() => await SendAsync(command));
Assert.Equal(System.Net.HttpStatusCode.Unauthorized, ex.Code);
}
public async Task Expect_Login_Account()
{
var email = "*****@*****.**";
var pwd = "1q2w3e4r";
var accountCreate = new SignUp.Command()
{
Account = new SignUp.AccountSignUpDto
{
Email = email,
FullName = "Test User",
Password = pwd,
PasswordAgain = pwd
}
};
var accountCreateResult = await SendAsync(accountCreate);
Assert.NotNull(accountCreateResult);
Assert.True(accountCreateResult.IsSucceeded);
var command = new Login.Command()
{
Account = new Login.AccountLoginDto()
{
Email = email,
Password = pwd
}
};
var loginResult = await SendAsync(command);
Assert.NotNull(loginResult);
Assert.True(loginResult.IsSucceeded);
}
public async Task Expect_Login()
{
var salt = Guid.NewGuid().ToByteArray();
var person = new Person
{
Username = "******",
Email = "email",
Hash = new PasswordHasher().Hash("password", salt),
Salt = salt
};
await InsertAsync(person);
var command = new Login.Command()
{
User = new Login.UserData()
{
Email = "email",
Password = "******"
}
};
var user = await SendAsync(command);
Assert.NotNull(user?.User);
Assert.Equal(user.User.Email, command.User.Email);
Assert.Equal("username", user.User.Username);
Assert.NotNull(user.User.Token);
}
public async Task <TokenDto> LoginAsync(LoginDto loginDto, string remoteIpAddress)
{
Login.Command command = _mapper.Map <Login.Command>(loginDto);
command.RemoteIpAddress = remoteIpAddress;
var token = await _mediator.Send(command);
return(_mapper.Map <TokenDto>(token));
}
public async Task <ActionResult <Login.CommandResponse> > Login([FromBody] Login.Command request)
{
var result = await _mediator.Send(request);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <ActionResult> LoginAsync()
{
var cmd = new Login.Command(
this.User.Identifier(),
this.Request.HttpContext.Connection.RemoteIpAddress.ToString());
await _mediator.Send(cmd);
return(this.Redirect("~/"));
}
public async Task CanLogin(SliceFixture fixture)
{
// Arrange
var loginCommand = new Login.Command
{
UserName = "******",
Password = "******"
};
// Act
await fixture.SendAsync(loginCommand);
}
public void Should_Map()
{
// Arrange
var dto = new LoginDto
{
Password = UserSeedData.ValidPassword,
UsernameOrEmail = UserTestSeedData.Performer.UserName
};
// Act
Login.Command command = _mapper.Map <Login.Command>(dto);
// Assert
command.Should().BeEquivalentTo(dto);
}
private Account GetGlobalTestAccount()
{
lock (Locker)
{
if (TestAccount == null)
{
var email = "*****@*****.**";
var pwd = "1q2w3e4r";
var command = new SignUp.Command()
{
Account = new SignUp.AccountSignUpDto
{
Email = email,
FullName = "Test User",
Password = pwd,
PasswordAgain = pwd
}
};
var result = SendAsync(command).GetAwaiter().GetResult();
var loginCmd = new Login.Command()
{
Account = new Login.AccountLoginDto()
{
Email = email,
Password = pwd
}
};
var accountDto = SendAsync(loginCmd)
.GetAwaiter()
.GetResult()
.Result;
TestAccount = new Account()
{
CreatedAt = DateTime.Now,
Email = accountDto.Email,
FullName = accountDto.FullName,
Id = accountDto.Id,
Role = "user"
};
}
return(TestAccount);
}
}
public async Task Should_Login_User()
{
// Arrange
const string expectedToken = "TestToken";
User user = FakeUsers.Performer;
var query = new Login.Command {
UsernameOrEmail = user.UserName, Password = UserSeedData.ValidPassword
};
_jwtGenerator.CreateTokensAsync(Arg.Any <User>(), Arg.Any <string>()).Returns(expectedToken);
// Act
string token = await _handler.Handle(query, new CancellationToken());
// Assert
token.Should().BeEquivalentTo(expectedToken);
}
public async Task <ActionResult> LoginAsync()
{
var cmd = new Login.Command(
User.Identifier(),
Request.HttpContext.Connection.RemoteIpAddress.ToString());
var result = await _mediator.Send(cmd);
if (result != "")
{
_logger.LogError("Unable to login: "******"~/"));
}
public void Should_Throw_Authentication_Exception_If_Password_Is_not_Valid_Or_User_Is_Lockedout()
{
// Arrange
User user = FakeUsers.Performer;
var command = new Login.Command {
UsernameOrEmail = user.UserName, Password = "******"
};
for (int i = 0; i < 3; i++)
{
// Act
Func <Task> func = async() => await _handler.Handle(command, new CancellationToken());
// Assert
func.Should().Throw <AuthenticationException>().WithMessage("The system could not log you in. Please enter a valid user name and password");
}
// Act
Func <Task> func1 = async() => await _handler.Handle(command, new CancellationToken());
// Assert
func1.Should().Throw <AuthorizationException>().WithMessage("Your account is locked out. Kindly wait for 10 minutes and try again");
}
public async Task <AuthUserDto> Login(
[FromBody] Login.Command command)
{
return(await _mediator.Send(command));
}
public async Task <TokenResponse> Login(Login.Command command)
{
return(await Mediator.Send(command));
}
public async Task <ActionResult <ServiceResultDto <string> > > Login([FromBody] Login.Command command)
{
var result = await this.Mediator.Send(command);
return(result.IsSuccess ? (ActionResult <ServiceResultDto <string> >) this.Ok(result) : this.BadRequest(result));
}
public async Task <IActionResult> Login(Login.Command command, CancellationToken cancellationToken)
{
UserDto user = await Mediator.Send(command, cancellationToken);
return(Ok(user));
}
public async Task <ActionResult <AuthUserDTO> > Login(Login.Command login)
{
return(await mediator.Send(login));
}
public async Task <ActionResult <UserDto> > Login(Login.Command command)
{
return(await Mediator.Send(command));
}
public async Task <UserEnvelope> Login([FromBody] Login.Command command)
{
return(await _mediator.Send(command));
}
public async Task <UserDTO> Login(Login.Command command)
{
return(await _mediator.Send(command));
}
public Task <UserEnvelope> Login([FromBody] Login.Command command, CancellationToken cancellationToken)
{
return(_mediator.Send(command, cancellationToken));
}
