public void Authenticate_should_return_badRequestObjectResult_on_not_registered_login_attempt_and_OkObjectResult_and_auth_token_on_registered_user()
{
var randomUserRequest = Fixture.Create <UserRequest>();
var actualUserRequest = new UserRequest
{
FirstName = _userData.FirstName,
Id = _userData.Id,
LastName = _userData.LastName,
Password = _mockPassword,
Username = _userData.Username
};
// Act
var response1 = Controller.Authenticate(randomUserRequest).GetAwaiter().GetResult();
var response2 = Controller.Authenticate(actualUserRequest).GetAwaiter().GetResult();
var value = ((UserModel)((OkObjectResult)response2.Result).Value);
// Assert
Assert.AreEqual(typeof(BadRequestObjectResult), ((BadRequestObjectResult)response1.Result).GetType());
Assert.AreEqual(typeof(OkObjectResult), ((OkObjectResult)response2.Result).GetType());
Assert.AreEqual(value.Id, _userData.Id);
Assert.AreEqual(value.FirstName, _userData.FirstName);
Assert.AreEqual(value.LastName, _userData.LastName);
Assert.AreEqual(value.Username, _userData.Username);
Assert.AreNotEqual(value.Token, string.Empty);
}
public async void Authenicate_ValidUser_Success()
{
await usersController.Register(validRegisterRquest);
var authRequest = new AuthenticateRequest()
{
Email = validRegisterRquest.Email,
Password = validRegisterRquest.Password
};
var result = await usersController.Authenticate(authRequest);
var okResult = result.Should().BeOfType <OkObjectResult>().Subject;
var authResponse = okResult.Value.Should().BeAssignableTo <AuthenticateResponse>().Subject;
authResponse.AccessToken.Should().NotBeNullOrEmpty();
Assert.NotNull(jwtTokenHelper.ValidateToken(authResponse.AccessToken));
authResponse.RefreshToken.Should().NotBeNullOrEmpty();
authResponse.User.Should().NotBeNull();
authResponse.User.Name.Should().Be(validRegisterRquest.Name);
authResponse.User.Email.Should().Be(validRegisterRquest.Email);
Assert.True(Utilities.ValidatePassword(validRegisterRquest.Password, authResponse.User.Password));
authResponse.User.Role.Should().Be(Entities.Role.User);
authResponse.User.Type.Should().Be(AccountType.Local);
}
public async Task Authenticate_WithCorrectUsernameAndPassword_ReturnStatusCodeOK()
{
// Arrange
var request = new AuthenticationRequest
{
Username = "******",
Password = "******"
};
var response = new AuthenticationResponse
{
Username = "******",
Role = "Admin",
Token = "AAAAA"
};
userService
.AuthenticateAsync(Arg.Any <string>(), Arg.Any <string>())
.Returns(Task.FromResult(response));
// Act
var actionResult = await usersController.Authenticate(request);
var objectResult = actionResult as OkObjectResult;
// Assert
Assert.NotNull(objectResult);
Assert.Equal((int)System.Net.HttpStatusCode.OK, objectResult.StatusCode);
}
public void Authenticate_ValidCredentials()
{
var user = GetAuthDTO();
var result = usersController.Authenticate(user) as OkObjectResult;
Assert.IsNotNull(result);
Assert.AreNotEqual(result.StatusCode, (int)HttpStatusCode.BadRequest);
}
public void Authenticate_Ok()
{
//act
var response = controller.Authenticate(new User()
{
Username = "******", Password = "******"
});
//assert
Assert.IsType <OkObjectResult>(response);
}
public void Invalid_Login()
{
var response = _userController.Authenticate(new Entities.User()
{
Username = "******", Password = "******"
});
var okObjectResult = response as OkObjectResult;
Assert.NotNull(okObjectResult);
}
public async Task Authenticate_UserCredentialsIsCorrect_ReturnsToken()
{
_mockUserRepository.Setup(x => x.Authenticate("abc", "abc")).ReturnsAsync(new UserRolesDTO());
var result = await _controller.Authenticate(new UserDTO { Username = "******", Password = "******" });
// Assert
Assert.Pass();
var okObjectResult = result as OkObjectResult;
Assert.IsNotNull(okObjectResult);
Assert.Equals(new UserRolesDTO(), result);
}
public async void Authenticate_HappyPath()
{
userRepo.Setup(x => x.Authenticate(It.IsAny <String>(), It.IsAny <String>()))
.ReturnsAsync((String userName, String password) =>
fixture.Build <User>()
.With(x => x.Username, userName)
.Create());
var user = fixture.Create <UserDto>();
var res = await usersController.Authenticate(user);
var okResult = Assert.IsType <OkObjectResult>(res);
}
public void Authenticate()
{
var user = new User()
{
Email = "Email1",
Password = "******",
};
var result = _controller.Authenticate(user) as ObjectResult;
Assert.True(result != null, "result is null");
Assert.True(result.StatusCode == 200, "Status code is not OK");
Assert.True((result.Value as User).Name == "Name1", "Name is not correct");
}
public void GivenExistingUserDTO_WhenAuthenticate_ThenReturnOk()
{
//given
UserDTO userDTO = new UserDTO {
Email = "*****@*****.**", Password = "******"
};
_userAuthService.Authenticate(userDTO.Email, userDTO.Password).Returns(new JwtSecurityToken());
//when
OkObjectResult returnValue = (OkObjectResult)_usersController.Authenticate(userDTO).Result;
//then
Assert.Equal(200, returnValue.StatusCode);
}
public void Authenticate_ReturnsOkResult()
{
_mockRepo.Setup(repo => repo.Authenticate("test1", "test")).Returns(new User {
Token = "12123hfgzxbcheoeopwer123nfjvnfjvfvvbifhbvvbivb"
});
var okResult = _controller.Authenticate(new User {
Username = "******", Password = "******"
}) as OkObjectResult;
// Assert
Assert.IsType <OkObjectResult>(okResult);
var userObject = Assert.IsType <User>(okResult.Value);
Assert.NotNull(userObject.Token);
}
public void Authenticate_ServiceReturnAUser_AuthenticateReturnsAnOkObjectResult()
{
//Arrange
var expectedType = typeof(OkObjectResult);
var expectedStatusCode = (int)HttpStatusCode.OK;
var fakeService = A.Fake <IUserService>();
var fakeMapper = A.Fake <IMapper>();
var fakeSettings = A.Fake <IOptions <AppSettings> >();
var fakeLogger = A.Fake <ILogger <UsersController> >();
var fakeJWTHelper = A.Fake <IJWTHelper>();
var fakeUser = A.Fake <User>();
var fakeUserDTO = A.Fake <UserDTO>();
var fakeUserName = "";
var fakePassword = "";
var fakeRole = "";
var fakeToken = "";
A.CallTo(() => fakeService.Authenticate(fakeUserName, fakePassword)).Returns((fakeUserDTO, fakeRole));
A.CallTo(() => fakeJWTHelper.GenerateTokenString(fakeUserDTO, fakeRole, fakeSettings)).Returns(fakeToken);
var sut = new UsersController(fakeService, fakeSettings, fakeLogger, fakeJWTHelper);
//Act
var result = sut.Authenticate(fakeUserDTO) as OkObjectResult;
//Assert
Assert.Equal(expectedType, result.GetType());
Assert.Equal(expectedStatusCode, result.StatusCode);
}
public async Task Authenticate_ValidCredentials_ReturnsOk()
{
var model = new LoginViewModel
{
Username = "******",
Password = "******"
};
var userStoredInDatabase = new User
{
Username = "******",
Password = "******"
};
var fakeUserRepository = new Mock <IUserRepository>();
fakeUserRepository
.Setup(repository => repository.GetUserWithPasswordByUsername(It.IsAny <string>()))
.ReturnsAsync(userStoredInDatabase);
var fakePasswordHasher = new Mock <IPasswordHasherService>();
fakePasswordHasher
.Setup(passwordHasher => passwordHasher.VerifyPassword(It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
var fakeTokenService = new Mock <ITokenService>();
var usersController = new UsersController(
fakeUserRepository.Object,
fakePasswordHasher.Object,
fakeTokenService.Object);
ActionResult <LoginResponseViewModel> result = await usersController.Authenticate(model);
result.Result.Should().BeOfType <OkObjectResult>();
}
public async Task Authenticate_valid_credendial()
{
var result1 = (OkObjectResult)await usersController.Create(user);
var u = (User)result1.Value;
//Act
var result = (OkObjectResult)await usersController.Authenticate(new User()
{
username = u.username, password = "******"
});
// Assert
Assert.AreEqual(200, result.StatusCode);
Assert.IsNotNull(((User)result.Value).token);
}
public void AuthenticateUser_Returns_OkObjectResult()
{
// Arrange
var userRepositoryMock = new Mock <IUserRepository>();
var userIMapperMock = new MapperConfiguration(config =>
{
config.AddProfile(new MovieMapper());
});
var userMapper = userIMapperMock.CreateMapper();
UsersController userApiController = new UsersController(userRepositoryMock.Object, mapper: userMapper);
var userDto = new UserAuthDTO()
{
Password = "******",
UserName = "******"
};
var userModel = new UserModel()
{
FirstName = "Gabriel",
LastName = "Isaac",
Email = "*****@*****.**",
Password = "******",
UserName = "******"
};
userRepositoryMock.Setup(repo => repo.Authenticate(userDto.UserName, userDto.Password)).Returns(userModel);
// Act
var userResult = userApiController.Authenticate(userDto);
var okResult = userResult as OkObjectResult;
// Assert
Assert.True(okResult.StatusCode is StatusCodes.Status200OK);
}
public void ItShouldAuthenticateWhenGettingActualUser()
{
var users = new List <User> {
new User {
Id = 1
}
};
var repository = new Mock <IUserRepository>();
repository.Setup(x => x.AllIncluding(It.IsAny <Expression <Func <User, object> > >())).Returns(
() => users.AsQueryable());
var controller = new UsersController(repository.Object);
HttpConfiguration configuration = new HttpConfiguration();
var request = new Mock <HttpRequestMessage>();
controller.Request = request.Object;
controller.Request.Properties["MS_HttpConfiguration"] = configuration;
var result = controller.Authenticate(new User {
Username = "******", Password = "******"
});
var user = result.Content.ReadAsAsync <User>();
Assert.AreEqual(1, user.Id);
}
public void TestValidAuthenticateRequestShouldReturnOk()
{
var auth = new AuthenticateRequest
{
Username = "******",
Password = "******"
};
var actual = _controller.Authenticate(auth);
Assert.IsInstanceOfType(actual, typeof(OkObjectResult));
}
public void Successful_login_return_token_with_ok_result()
{
//given
userDto = new UserDto {
Username = "******", Password = "******"
};
var user = new User {
Id = 1, Username = userDto.Username, FirstName = "ajeet", LastName = "kumar", PasswordHash = System.Text.Encoding.Unicode.GetBytes("text"), PasswordSalt = System.Text.Encoding.Unicode.GetBytes("text")
};
moqUserService.Setup(m => m.Authenticate(It.IsAny <string>(), It.IsAny <string>())).Returns(user);
//when
IActionResult actionResult = sut.Authenticate(userDto);
var contentResult = actionResult as OkObjectResult;
//then
Assert.IsNotNull(contentResult);
Assert.AreEqual(200, contentResult.StatusCode);
}
public async Task Authenticate_WithGivenViewModel_Returns_OkObjectResult()
{
//Arrange
var user = new UserLoginResponseViewModel
{
Email = "*****@*****.**",
DisplayName = "UserTest"
};
_mockUserService
.Setup(x => x.Authenticate(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(user));
//Act
var result = await _usersController.Authenticate(new UserLoginRequestViewModel()) as ObjectResult;
//Assert
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
}
public async Task TestLogin()
{
var dbContext = DbContextMocker.GetContext(nameof(this.TestLogin));
var usersRepository = new UserRepository(dbContext);
var usersService = new UserService(usersRepository, null);
var appsettings = Options.Create(new WebApi.Configuration.AppSettings()
{
Secret = "TESTSUPERSECRETKEYINTESTING",
});
var controller = new UsersController(usersService, appsettings)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext(),
},
};
var userLogin = new UserLoginModel()
{
Username = "******",
Password = "******",
};
var response = await controller.Authenticate(userLogin);
var value = response.Value;
Assert.Equal("Administrator", value.Role);
userLogin = new UserLoginModel()
{
Username = "******",
Password = "******",
};
response = await controller.Authenticate(userLogin);
Assert.Equal((int)HttpStatusCode.Unauthorized, (response.Result as UnauthorizedObjectResult).StatusCode);
}
public void AuthenticateTest()
{
User user = GetUser();
ValidationResponse <User> validationResponse = GetOkValidationResponse();
AuthenticateModel authenticateModel = GetAuthenticateModel();
UserResponseModel userResponse = GetUserResponseModel();
_mockService
.Setup(serv => serv.Authenticate(authenticateModel.Email, authenticateModel.Password))
.Returns(validationResponse);
_mockMapper
.Setup(mapper => mapper.Map <User, UserResponseModel>(validationResponse.ResponseData))
.Returns(userResponse);
IActionResult actionResult = _controller.Authenticate(authenticateModel);
OkObjectResult actual = (OkObjectResult)actionResult;
string actualEmail = ((UserResponseModel)actual.Value).Email;
Assert.Equal(user.Email, actualEmail);
Assert.Equal(StatusCodes.Status200OK, actual.StatusCode);
}
public async void Authenticate_Returns_UnauthorizedResult()
{
var dto = new UserPasswordDto
{
Email = "*****@*****.**",
Password = "******"
};
_userService
.Setup(s => s.AuthenticateAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult <UserDto>(null));
var result = await _usersController.Authenticate(dto);
Assert.IsType <UnauthorizedResult>(result);
}
public async Task LoginTest()
{
var loginRequest = CreateLoginRequest();
var loginFake = GetUser().FirstOrDefault();
var user = _repoMock.Setup(f => f.AuthenticateAsync(loginRequest)).Returns(Task.FromResult(loginFake));
Assert.IsNotNull(user, "Usuario invalido");
var usersController = new UsersController(_repoMock.Object);
var actionResult = await usersController.Authenticate(loginRequest);
Assert.IsNotNull(actionResult, "usuario não encontrado");
Assert.IsInstanceOfType(actionResult, typeof(OkObjectResult));
}
public async Task Authenticate_should_be_fail_unauthorize()
{
var userServiceMock = new Mock <IUserService>();
userServiceMock.Setup(service => service.AuthenticateAsync(It.IsAny <AuthenticateRequest>()))
.ReturnsAsync(GetAuthenticateResponse_Fail());
var controller = new UsersController(userServiceMock.Object);
var actionResult = await controller.Authenticate(It.IsAny <AuthenticateRequest>());
var result = Assert.IsType <ObjectResult>(actionResult);
var resultValue = Assert.IsType <AuthenticateResponse>(result.Value);
Assert.NotNull(result.Value);
Assert.False(resultValue.Status == System.Net.HttpStatusCode.OK);
}
public void ITShouldThrowExceptionWhenNotFound()
{
var users = new List <User>();
var repository = new Mock <IUserRepository>();
repository.Setup(x => x.AllIncluding(It.IsAny <Expression <Func <User, object> > >())).Returns(
() => users.AsQueryable());
var controller = new UsersController(repository.Object);
HttpConfiguration configuration = new HttpConfiguration();
var request = new Mock <HttpRequestMessage>();
controller.Request = request.Object;
controller.Request.Properties["MS_HttpConfiguration"] = configuration;
var result = controller.Authenticate(new User {
Username = "******", Password = "******"
});
}
public async Task Authenticate_given_wrong_Password_match_Returns_BadRequest_and_error_message()
{
var token = "verysecrettoken";
var id = 1;
var user = new User
{
Email = "test@Test",
Password = "******",
};
var dto = new AuthenticateDTO
{
Email = user.Email,
Password = "******",
};
var userDTO = new DetailedUserDTO
{
UserId = id,
Email = dto.Email,
UserRole = UserRoleEnum.Receiver.ToString(),
FirstName = "test",
SurName = "test"
};
var responseText = "Username or password is incorrect";
var repository = new Mock <IUserRepository>();
repository.Setup(s => s.Authenticate(user.Email, user.Password)).ReturnsAsync((userDTO, token));
var logger = new Mock <ILogger <UsersController> >();
var controller = new UsersController(repository.Object, logger.Object);
var authenticate = await controller.Authenticate(dto);
var result = authenticate.Result as BadRequestObjectResult;
Assert.IsType <BadRequestObjectResult>(authenticate.Result);
Assert.Equal(responseText, result.Value);
}
public void GetToken()
{
var serviceProvider = new ServiceCollection()
.AddLogging()
.BuildServiceProvider();
var factory = serviceProvider.GetService <ILoggerFactory>();
var logger = factory.CreateLogger <UsersController>();
var controller = new UsersController(_userService, logger);
// Act
User user = new User();
user.Username = "******";
user.Password = "******";
var result = controller.Authenticate(user);
Assert.NotNull(result);
}
public void should_authenticate()
{
var userServiceMock = new Mock <IUserService>();
userServiceMock.Setup(usm => usm.Authenticate(It.IsAny <AuthenticateRequest>())).Returns(new AuthenticateResponse(new User {
ID = 1,
Password = "******",
Role = "TestROle",
Username = "******"
}, "TOKENTOEKN"));
var userController = new UsersController(userServiceMock.Object);
var result = userController.Authenticate(new AuthenticateRequest()
{
username = "******",
password = "******"
});
Assert.That(GetHttpStatusCode(result), Is.EqualTo(HttpStatusCode.OK));
Assert.That(GetValue <AuthenticateResponse>(result).Id, Is.EqualTo(1));
}
public void TestAuthenticate()
{
var request = new UserViewModel
{
Username = "******",
Password = "******",
};
var actionResult = _controller.Authenticate(request);
Assert.IsAssignableFrom <IActionResult>(actionResult);
bool IsValid = (int)actionResult.GetType().GetProperty("StatusCode").GetValue(actionResult, null) == 200;
Assert.True(IsValid);
var userDto = (UserViewModel)actionResult.GetType().GetProperty("Value").GetValue(actionResult);
IsValid = userDto.ErrorMessage?.FirstOrDefault() == null;
Assert.True(IsValid);
}
public async Task UserCanAuthenticate()
{
var user = Helper.GenerateRandomUser();
var mapper = Helper.CreateMapperWithProfiles(new UserProfile());
var mock = new Mock <IUserRepository>();
mock.Setup(x => x.FindUserAsync(user.Email, UserService.HashPassword(user.Password))).ReturnsAsync(user);
var service = new UserService(Helper.Configuration, mapper, mock.Object);
var controller = new UsersController(service);
var response = await controller.Authenticate(new AuthenticateRequest
{
Email = user.Email,
Password = user.Password
});
Assert.IsType <AcceptedResult>(response.Result);
Assert.NotNull(((AcceptedResult)response.Result).Value);
}
