public void Should_have_error_when_email_is_null_or_empty()
{
var _customerSettings = new CustomerSettings();
var _stateProvinceService = new Mock <IStateProvinceService>();
var _validator = new RegisterValidator(_localizationService, _stateProvinceService.Object, _customerSettings);
var model = new RegisterModel
{
Email = null
};
_validator.ShouldHaveValidationErrorFor(x => x.Email, model);
model.Email = "";
_validator.ShouldHaveValidationErrorFor(x => x.Email, model);
}
public void AuthenticateShouldLoginTheRegisteredUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginTheRegisteredUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var validatorUser = new UserRoleValidator();
var crValidator = new CreateValidator();
var userUserRoleService = new UserUserRoleService(validatorUser, context);
var usersService = new UsersService(context, validator, crValidator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Created for test"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab6.Viewmodels.RegisterPostModel
{
FirstName = "Catalin",
LastName = "Albulescu",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
var result = usersService.Register(added);
var authenticated = new Lab6.Viewmodels.LoginPostModel
{
Username = "******",
Password = "******"
};
//valid authentification
var authresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
//invalid user authentification
//var authresult1 = usersService.Authenticate("unknown", "abcdefg");
//Assert.IsNull(authresult1);
}
}
public void Save()
{
try
{
bool IsSaved = false;
UsersDTO temp = new UsersDTO();
/// operations required for fluent validation
RegisterValidator reg = new RegisterValidator(CurrentUser);
ValidationResult results = reg.Validate(CurrentUser);
if (!results.IsValid)
{
Message = results.Errors[0].ToString();
}
else
{
temp.Id = CurrentUser.Id;
temp.FirstName = CurrentUser.FirstName;
temp.LastName = CurrentUser.LastName;
temp.Email = CurrentUser.Email;
temp.Password = CurrentUser.Password;
temp.PasswordConfirm = CurrentUser.PasswordConfirm;
temp.UserName = CurrentUser.UserName;
if (!results.IsValid)
{
Message = results.Errors[0].ToString();
}
else
{
IsSaved = userService.Register(temp);
LoadData();
}
}
if (IsSaved)
{
Message = "User saved";
}
}
catch (Exception ex)
{
Message = ex.Message;
}
}
public void Should_validate_password_min_digits()
{
_customerSettings.MinDigitsInPassword = 3;
_validator = new RegisterValidator(T, _customerSettings, _taxSettings);
var model = new RegisterModel();
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public void Should_validate_password_is_length()
{
_customerSettings.PasswordMinLength = 5;
_validator = new RegisterValidator(T, _customerSettings, _taxSettings);
var model = new RegisterModel();
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public void Should_validate_password_min_uppercase_chars()
{
_customerSettings.MinUppercaseCharsInPassword = 4;
_validator = new RegisterValidator(T, _customerSettings, _taxSettings);
var model = new RegisterModel();
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public void Register_Validation_ShouldValidate(string username, string password, string firstName, string lastName, bool valid)
{
RegisterInputModel registerInput = new RegisterInputModel {
Username = username,
Password = password,
FirstName = firstName,
LastName = lastName
};
RegisterValidator validator = new RegisterValidator();
ValidationResult result = validator.Validate(registerInput);
result.IsValid.Should().Be(valid);
}
public void Should_not_have_error_when_firstName_is_specified()
{
var _customerSettings = new CustomerSettings
{
FirstNameEnabled = true
};
var _stateProvinceService = new Mock <IStateProvinceService>();
var _validator = new RegisterValidator(_localizationService, _stateProvinceService.Object, _customerSettings);
var model = new RegisterModel
{
FirstName = "John"
};
_validator.ShouldNotHaveValidationErrorFor(x => x.FirstName, model);
}
public void Should_validate_password_min_special_chars()
{
_customerSettings.MinSpecialCharsInPassword = 2;
_validator = new RegisterValidator(T, _customerSettings, _taxSettings);
var model = new RegisterModel();
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
model.ConfirmPassword = model.Password;
_validator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public IActionResult Register([FromBody] RegisterDto dto
, [FromServices] IRegisterCommand command
, [FromServices] RegisterValidator validator)
{
var result = validator.Validate(dto);
if (result.IsValid)
{
ApplicationUser applicationUser = _mapper.Map <ApplicationUser>(dto);
_executor.ExecuteCommand(command, applicationUser);
return(Ok("Application user created successfully"));
}
return(UnprocessableEntity(UnprocessableEntityResponse.Message(result.Errors)));
}
public void AuthenticateShouldLogTheRegisteredUser()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheRegisteredUser))
.Options;
using (var context = new MoviesDbContext(options))
{
var validator = new RegisterValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRoleService(validatorUser, context);
var usersService = new UsersService(context, validator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRole.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab3Movie.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new Lab3Movie.ViewModels.LoginPostModel
{
Username = "******",
Password = "******"
};
//valid authentification
var authresult = usersService.Authenticate(added.UserName, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.UserName);
//invalid user authentification
var authresult1 = usersService.Authenticate("unknown", "abcdefg");
Assert.IsNull(authresult1);
}
}
public void ShouldNotHaveErrorWhenFirstnameIsSpecified()
{
var customerSettings = new CustomerSettings
{
FirstNameEnabled = true
};
var validator = new RegisterValidator(GetService <ILocalizationService>(), GetService <IStateProvinceService>(), customerSettings);
var model = new RegisterModel
{
FirstName = "John"
};
validator.ShouldNotHaveValidationErrorFor(x => x.FirstName, model);
}
public void ShouldNotHaveErrorWhenLastNameIsSpecified()
{
var customerSettings = new CustomerSettings
{
LastNameEnabled = true
};
var validator = new RegisterValidator(GetService <ILocalizationService>(), GetService <IStateProvinceService>(), customerSettings);
var model = new RegisterModel
{
LastName = "Smith"
};
validator.TestValidate(model).ShouldNotHaveValidationErrorFor(x => x.LastName);
}
public void Should_validate_password_is_length()
{
_customerSettings.PasswordMinLength = 5;
_validator = new RegisterValidator(_localizationService, _customerSettings);
var model = new RegisterModel();
model.Password = "******";
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_validator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public void Should_validate_on_RegisterModel_is_all_rule()
{
_registerValidator = new RegisterValidator(_userSettings);
var model = new RegisterViewModel()
{
Password = "******"
};
//password should equal confirmation password
model.ConfirmPassword = model.Password;
_registerValidator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
//password should equal confirmation password
model.ConfirmPassword = model.Password;
_registerValidator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public void Should_validate_on_RegisterModel_is_all_rule()
{
_registerValidator = new RegisterValidator(_localizationService, _stateProvinceService.Object, _customerSettings);
var model = new RegisterModel
{
Password = "******"
};
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_registerValidator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_registerValidator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public async Task <IActionResult> Register([FromBody] UserRegisterApiModel model)
{
var validator = new RegisterValidator(_recaptcha, _resourceManager);
var validResult = validator.Validate(model);
if (!validResult.IsValid)
{
return(BadRequest(new MessageApiModel()
{
Message = validResult.ToString()
}));
}
var RegisterResult = await _accountService.RegisterUserAsync(model);
return(Created("", RegisterResult));
}
public void GetCurentUserShouldReturnAccesToKlaims()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCurentUserShouldReturnAccesToKlaims))
.Options;
using (var context = new ExpensesDbContext(options))
{
var regValidator = new RegisterValidator();
var crValidator = new CreateValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRoleService(validatorUser, context);
var usersService = new UsersService(context, regValidator, crValidator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Created for test"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab6.Viewmodels.RegisterPostModel
{
FirstName = "firstName",
LastName = "lastName",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new Lab6.Viewmodels.LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.Username, added.Password);
//usersService.GetCurentUser(httpContext);
Assert.IsNotNull(authresult);
}
}
public void GetCurrentUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCurrentUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var registervalidator = new RegisterValidator();
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
UsersService usersService = new UsersService(context, registervalidator, config, user_userRoleService);
//UsersController usersController = new UsersController(usersService, null);
//usersController.ControllerContext = new Microsoft.AspNetCore.Mvc.ControllerContext();
//usersController.ControllerContext.HttpContext = new DefaultHttpContext();
// usersController.ControllerContext.HttpContext.Items.Add("user-Name", "Ghita");
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var resultAdded = usersService.Register(added);
var resultAuthentificate = usersService.Authenticate(added.Username, added.Password);
var user = context.Users.FirstOrDefault(user_userRole => user_userRole.Id == resultAuthentificate.Id);
//User userRole = usersService.GetCurrentUser(user);
Assert.IsNotNull(user);
//Assert.AreEqual(resultAuthentificate, userRole.Id);
}
}
public new void Setup()
{
_customerSettings = new CustomerSettings
{
PasswordMinLength = 8,
PasswordRequireUppercase = true,
PasswordRequireLowercase = true,
PasswordRequireDigit = true,
PasswordRequireNonAlphanumeric = true
};
_changePasswordValidator = new ChangePasswordValidator(_localizationService, _customerSettings);
_stateProvinceService = new Mock <IStateProvinceService>();
_registerValidator = new RegisterValidator(_localizationService, _stateProvinceService.Object, _customerSettings);
_passwordRecoveryConfirmValidator = new PasswordRecoveryConfirmValidator(_localizationService, _customerSettings);
_validator = new TestValidator();
_person = new Person();
}
public new void Setup()
{
_userSettings = new UserSettings
{
PasswordMinLength = 8,
PasswordRequireUppercase = true,
PasswordRequireLowercase = true,
PasswordRequireDigit = true,
PasswordRequireNonAlphanumeric = true
};
_changePasswordValidator = new ChangePasswordValidator(_userSettings);
_registerValidator = new RegisterValidator(_userSettings);
_forgotPasswordConfirmValidator = new ForgotPasswordConfirmValidator(_userSettings);
_validator = new TestValidator();
_person = new Person();
}
public void ShouldHaveErrorWhenFirstnameIsNullOrEmpty()
{
var customerSettings = new CustomerSettings
{
FirstNameEnabled = true,
FirstNameRequired = true
};
var validator = new RegisterValidator(GetService <ILocalizationService>(), GetService <IStateProvinceService>(), customerSettings);
var model = new RegisterModel
{
FirstName = null
};
validator.ShouldHaveValidationErrorFor(x => x.FirstName, model);
model.FirstName = string.Empty;
validator.ShouldHaveValidationErrorFor(x => x.FirstName, model);
}
public void Should_have_error_when_password_is_null_or_empty()
{
var _customerSettings = new CustomerSettings();
var _stateProvinceService = new Mock <IStateProvinceService>();
var _validator = new RegisterValidator(_localizationService, _stateProvinceService.Object, _customerSettings);
var model = new RegisterModel
{
Password = null
};
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "";
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
}
public void Should_have_error_when_lastName_is_null_or_empty()
{
var _customerSettings = new CustomerSettings
{
LastNameEnabled = true,
LastNameRequired = true
};
var _stateProvinceService = new Mock <IStateProvinceService>();
var _validator = new RegisterValidator(_localizationService, _stateProvinceService.Object, _customerSettings);
var model = new RegisterModel
{
LastName = null
};
_validator.ShouldHaveValidationErrorFor(x => x.LastName, model);
model.LastName = "";
_validator.ShouldHaveValidationErrorFor(x => x.LastName, model);
}
public void AuthenticateShouldLogInAUser()
{
var options = new DbContextOptionsBuilder <TasksDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogInAUser))
.Options;
using (var context = new TasksDbContext(options))
{
var validator = new RegisterValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRolesService(validatorUser, context);
var usersService = new UsersService(context, validator, null, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "For testing..."
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new LabIV.DTO.RegisterPostDTO
{
FirstName = "Julia",
LastName = "Bush",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new LabIV.DTO.LoginPostDTO
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
}
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// validate for unique email and username
RegisterValidator validator = new RegisterValidator();
ValidationResult results = validator.Validate(model);
if (!results.IsValid)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
// default role
string role = "Employee";
if (model.Role != null && model.Role != "")
{
role = model.Role;
}
var user = new ApplicationUser()
{
UserName = model.UserName, Email = model.UserName,
FirstName = model.FirstName, LastName = model.LastName,
HomeAddress = model.HomeAddress, PhoneNumber = model.PhoneNumber, BirthDate = model.BirthDate, Gender = model.Gender,
Role = role,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
private void CanSaveAccount()
{
ValidationResult result = new RegisterValidator().Validate(AccountVM);
//Get validation errors
if (result.Errors.Count() == 0)
{
//if validated update account
_userRepo.UpdateAccount(new Account()
{
AccountID = AccountVM.Id,
Gebruikersnaam = AccountVM.Username,
Wachtwoord = AccountVM.Password,
Rol = AccountVM.Role,
DatumCertificering = AccountVM.DateOfCertification,
EinddatumCertificering = AccountVM.EndDateOfCertification,
Voornaam = AccountVM.FirstName,
Tussenvoegsel = AccountVM.Infix,
Achternaam = AccountVM.LastName,
Straatnaam = AccountVM.StreetName,
Stad = AccountVM.City,
Huisnummer = AccountVM.HouseNumber,
Telefoonnummer = AccountVM.PhoneNumber,
Email = AccountVM.Email,
IBAN = AccountVM.IBAN,
LaatsteWijziging = DateTime.Now
});
Messenger.Default.Send("Wijzigingen opgeslagen", this.GetHashCode());
}
else
{
//Get error messages as string
string message = "";
foreach (ValidationFailure failure in result.Errors)
{
message += (failure.ErrorMessage + "\n");
}
//Use messenger to send error message to view
//(Hashcode to match view and viewmodel - see code behind)
Messenger.Default.Send(message, this.GetHashCode());
}
}
public AuthController
(
ILoginUseCase loginUseCase,
IRegisterUserUseCase registerUserUseCase,
LoginPresenter loginPresenter,
RegisterUserPresenter registerUserPresenter,
LoginValidator loginValidator,
RegisterValidator registerValidator,
IWebHostEnvironment env
)
{
_loginUseCase = loginUseCase;
_registerUserUseCase = registerUserUseCase;
_loginPresenter = loginPresenter;
_registerUserPresenter = registerUserPresenter;
_loginValidator = loginValidator;
_registerValidator = registerValidator;
_env = env;
}
public void UpsertShouldModifyFieldsValues()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyFieldsValues))
.Options;
using (var context = new ExpensesDbContext(options))
{
var user = new User();
var registerValidator = new RegisterValidator();
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
UsersService usersService = new UsersService(context, registerValidator, config, user_userRoleService);
var expected = new RegisterPostModel
{
FirstName = "Ion",
LastName = "Ion",
Username = "******",
Email = "*****@*****.**",
Password = "******",
//UserRoles = "UserManager"
};
usersService.Create(expected);
var updated = new UserPostModel
{
FirstName = "ana",
LastName = "ana",
Username = "******",
Email = "*****@*****.**",
Password = "******",
// UserRoles = "Admin"
};
var userUpdated = usersService.Upsert(6, updated); //id 6 ca daca e 1 da as no tracking
Assert.NotNull(userUpdated);
Assert.AreEqual("ana", userUpdated.FirstName);
Assert.AreEqual("ana", userUpdated.LastName);
}
}
public void ValidRegisterShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))
.Options;
var registerValidator = new RegisterValidator();
using (var context = new ExpensesDbContext(options))
{
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
UsersService usersService = new UsersService(context, registerValidator, config, user_userRoleService);
var userRole = new UserRole
{
Name = "Regular"
};
context.UserRoles.Add(userRole);
context.SaveChanges();
var added = new RegisterPostModel()
{
FirstName = "User",
LastName = "Test",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
//ErrorsCollection errorsCollection = new ErrorsCollection
//{
// Entity = nameof(RegisterPostModel),
// ErrorMessages = new List<string> { "The password must contain at least two digits!" }
//};
var addedResult = usersService.Register(added);
//context.SaveChanges();
Assert.IsNull(addedResult);
//Assert.AreEqual(errorsCollection, addedResult);
//Assert.AreEqual(added, addedResult);
}
}
public override IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var validator = new RegisterValidator();
var result = validator.Validate(this);
return result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName }));
}
public new void Setup()
{
_customerSettings = new CustomerSettings();
_validator = new RegisterValidator(_localizationService, _customerSettings);
}
public void Should_validate_password_is_length()
{
_customerSettings.PasswordMinLength = 5;
_validator = new RegisterValidator(_localizationService, _customerSettings);
var model = new RegisterModel();
model.Password = "******";
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_validator.ShouldHaveValidationErrorFor(x => x.Password, model);
model.Password = "******";
//we know that password should equal confirmation password
model.ConfirmPassword = model.Password;
_validator.ShouldNotHaveValidationErrorFor(x => x.Password, model);
}
public new void Setup()
{
_customerSettings = new CustomerSettings();
_stateProvinceService = MockRepository.GenerateMock<IStateProvinceService>();
_validator = new RegisterValidator(_localizationService, _stateProvinceService, _customerSettings);
}
