public async Task RegisterHttpPostSignInUserReturnsFailureTest()
{
var mockIUserStore = new Mock <IUserStore <User> >();
var mockIAuthenticationManager = new Mock <IAuthenticationManager>();
var mockApplicationUserManager = new Mock <ApplicationUserManager>(mockIUserStore.Object);
mockApplicationUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(default(User));
mockApplicationUserManager.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
var mockApplicationSignInManager = new Mock <ApplicationSignInManager>(mockApplicationUserManager.Object, mockIAuthenticationManager.Object);
mockApplicationSignInManager.Setup(x => x.PasswordSignInAsync(It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>()))
.ReturnsAsync(SignInStatus.Failure);
_accountController = new AccountController(mockApplicationUserManager.Object, mockApplicationSignInManager.Object, mockIAuthenticationManager.Object);
var viewModel = new AccountRegisterViewModel()
{
Email = "email",
Password = "******",
ConfirmPassword = "******"
};
var result = await _accountController.Register(viewModel);
Assert.IsInstanceOf <ViewResult>(result);
}
public async Task <IActionResult> Register(AccountRegisterViewModel vm)
{
if (ModelState.IsValid)
{
IdentityUser user = new IdentityUser(vm.Username);
user.Email = vm.Email;
IdentityResult result = await _userManagerService.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await _userManagerService.AddToRoleAsync(user, "Customer");
Profile newProfile = new Profile {
Username = vm.Username,
Email = vm.Email
};
_profileDataService.Create(newProfile);
return(RedirectToAction("Login", "Account"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError("", item.Description);
}
}
}
return(View(vm));
}
public async Task <IActionResult> Register(AccountRegisterViewModel vm)
{
if (ModelState.IsValid)
{
IdentityUser user = new IdentityUser(vm.Email);
user.Email = vm.Email;
IdentityResult result = await _userManagerService.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await _userManagerService.AddToRoleAsync(user, "Customer");
//add a new profile
Profile newProfile = new Profile {
Email = vm.Email, FirstName = vm.FirstName, LastName = vm.LastName, DOB = vm.DOB, IsAdmin = false
};
_profileDataService.Create(newProfile);
return(RedirectToAction("Login", "Account"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(vm));
}
public void AccountController_Register_CreateCalledOnce()
{
//Arrange
//чаще всего "мокаются" интерфейсы
Mock <UserManager <CustomIdentityUser> > userManager = new Mock <UserManager <CustomIdentityUser> >(); // для успешного теста нужно добавить все зависимости в конструктор
Mock <SignInManager <CustomIdentityUser> > signInManager = new Mock <SignInManager <CustomIdentityUser> >();
AccountRegisterViewModel registerViewModel = new AccountRegisterViewModel
{
FisrtName = "TestFisrtName",
LastName = "TestLastName",
UserName = "******",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
CustomIdentityUser user = new CustomIdentityUser
{
FisrtName = registerViewModel.FisrtName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
userManager.Setup(x => x.CreateAsync(user, registerViewModel.Password)).ReturnsAsync(IdentityResult.Success);
AccountController controller = new AccountController(userManager.Object, signInManager.Object);
//Act
controller.Register(registerViewModel);
//Assert
userManager.Verify(x => x.CreateAsync(user, registerViewModel.Password), Times.Once);
}
public async Task <IActionResult> Register(AccountRegisterViewModel vm)
{
if (ModelState.IsValid)
{
//add a new user
IdentityUser user = new IdentityUser(vm.Email);
user.Email = vm.Email;
IdentityResult result =
await _userManagerService.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
//go to Home/Index
return(RedirectToAction("Index", "Home"));
}
else
{
//show errors
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(vm));
}
public async Task <IActionResult> Register(AccountRegisterViewModel vm)
{
if (ModelState.IsValid)
{
var user = new RegisteredUser {
UserName = vm.Email, Email = vm.Email
};
var result = await userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await signInManager.SignInAsync(user, false);
return(RedirectToAction("Registered", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(vm));
}
public IActionResult Register(AccountRegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = registerViewModel.FirstName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.Email,
Email = registerViewModel.Email
};
var createTask = _userManager.CreateAsync(user, registerViewModel.Password);
if (createTask.Result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public async Task <IActionResult> Register(AccountRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = model.Email, Email = model.Email, EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Admin"));
}
else
{
string err = "";
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
err += error.Description + "\n";
}
//return RedirectToAction("Register", "Account");
return(Content(err));
}
}
else
{
//return RedirectToAction("Register", "Account");
return(Content("not valid"));
}
}
public IActionResult RegisterAdmin()
{
AccountRegisterViewModel vm = new AccountRegisterViewModel {
};
return(View(vm));
}
public async Task <IActionResult> Register(AccountRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User()
{
Email = model.Email,
UserName = model.Email,
Address = model.Address
};
var result = await userManager.CreateAsync(user : user, password : model.Passwork);
if (result.Succeeded)
{
await signInManager.SignInAsync(user : user, isPersistent : false);
return(RedirectToAction("Show", "Home"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError("", item.Description);
}
}
}
return(View(model));
}
public IActionResult Register(AccountRegisterViewModel viewModel)
{
if (ModelState.IsValid)
{
var user = new IdentityUser()
{
Email = viewModel.Email, UserName = viewModel.Email
};
var createTask = _userManager.CreateAsync(user, viewModel.Password);
if (createTask.Result.Succeeded)
{
_signInManager.SignInAsync(user, false);
_messageService.SendMessage(viewModel.Email, "you're registered");
return(RedirectToAction("Index", "Human"));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public async Task RegisterHttpPostEmailIsInUseTest()
{
var mockIUserStore = new Mock <IUserStore <User> >();
var mockIAuthenticationManager = new Mock <IAuthenticationManager>();
var mockApplicationUserManager = new Mock <ApplicationUserManager>(mockIUserStore.Object);
mockApplicationUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(new User());
var mockApplicationSignInManager = new Mock <ApplicationSignInManager>(mockApplicationUserManager.Object, mockIAuthenticationManager.Object);
_accountController = new AccountController(mockApplicationUserManager.Object, mockApplicationSignInManager.Object, mockIAuthenticationManager.Object);
var viewModel = new AccountRegisterViewModel()
{
Email = "email",
Password = "******",
ConfirmPassword = "******"
};
var result = await _accountController.Register(viewModel);
Assert.IsInstanceOf <ViewResult>(result);
}
public async Task RegisterHttpPostValidViewModelTest()
{
var mockIUserStore = new Mock <IUserStore <User> >();
var mockIAuthenticationManager = new Mock <IAuthenticationManager>();
var mockApplicationUserManager = new Mock <ApplicationUserManager>(mockIUserStore.Object);
mockApplicationUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(default(User));
mockApplicationUserManager.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
var mockApplicationSignInManager = new Mock <ApplicationSignInManager>(mockApplicationUserManager.Object, mockIAuthenticationManager.Object);
mockApplicationSignInManager.Setup(x => x.PasswordSignInAsync(It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>()))
.ReturnsAsync(SignInStatus.Success);
_accountController = new AccountController(mockApplicationUserManager.Object, mockApplicationSignInManager.Object, mockIAuthenticationManager.Object);
var viewModel = new AccountRegisterViewModel()
{
Email = "email",
Password = "******",
ConfirmPassword = "******"
};
var result = await _accountController.Register(viewModel) as RedirectToRouteResult;
Assert.AreEqual("Index", (string)result?.RouteValues["action"]);
}
public void RegisterHttpPostSignInUserReturnsRequiresVerificationTest()
{
var mockIUserStore = new Mock <IUserStore <User> >();
var mockIAuthenticationManager = new Mock <IAuthenticationManager>();
var mockApplicationUserManager = new Mock <ApplicationUserManager>(mockIUserStore.Object);
mockApplicationUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(default(User));
mockApplicationUserManager.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
var mockApplicationSignInManager = new Mock <ApplicationSignInManager>(mockApplicationUserManager.Object, mockIAuthenticationManager.Object);
mockApplicationSignInManager.Setup(x => x.PasswordSignInAsync(It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>()))
.ReturnsAsync(SignInStatus.RequiresVerification);
_accountController = new AccountController(mockApplicationUserManager.Object, mockApplicationSignInManager.Object, mockIAuthenticationManager.Object);
var viewModel = new AccountRegisterViewModel()
{
Email = "email",
Password = "******",
ConfirmPassword = "******"
};
Assert.ThrowsAsync <NotImplementedException>(async() => await _accountController.Register(viewModel));
}
public ActionResult Register(AccountRegisterViewModel viewModel)
{
if (ModelState.IsValid)
{
var user = new User()
{
Username = viewModel.Username,
FirstName = viewModel.FirstName,
LastName = viewModel.LastName
};
var success = _repo.Add(user, viewModel.Password);
if (success)
{
FormsAuthentication.SetAuthCookie(user.Username, false);
return(RedirectToAction("Index", "Bench"));
}
else
{
ModelState.AddModelError("", "Unable to register user");
}
}
return(View(viewModel));
}
public async Task <IActionResult> SignUp(AccountRegisterViewModel vm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
Email = vm.Email,
UserName = vm.Email,
Firstname = vm.Firstname,
Lastname = vm.Lastname,
PhotoPath = "no-photo.png",
RegisteredDate = DateTime.Now
};
var result = await this._userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await this._signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(vm));
}
public async Task <IActionResult> Register(AccountRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new IdentityUser
{
UserName = model.RegisterViewModel.Email,
Email = model.RegisterViewModel.Email
};
var result = await _userManager.CreateAsync(user, model.RegisterViewModel.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Index", "Account"));
}
}
else
{
return(RedirectToAction("Index", "Account"));
}
}
public async Task SignupAsync(string username, string password)
{
var signupModel = new AccountRegisterViewModel
{
Username = username,
Password = password,
Email = "*****@*****.**",
ConfirmPassword = password
};
await this.PostEnsureStatusAsync(
"/Account/Register",
signupModel.ToFormEncodedContent(),
HttpStatusCode.Redirect,
new Regex(@"/Account/Login\?confirmEmail=true", RegexOptions.IgnoreCase)
);
// Forcefully confirm email.
var userManager = this._server.Services.GetRequiredService <UserManager <ApplicationUser> >();
var user = await userManager.FindByNameAsync(username);
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
var result = await userManager.ConfirmEmailAsync(user, token);
Assert.True(result.Succeeded);
// Log in
await this.LoginAsync(username, password);
}
public async Task <IActionResult> Register(AccountRegisterViewModel m)
{
if (!ModelState.IsValid)
{
return(View(m));
}
var username = m.Username.Trim().ToLower();
var user = new BlogUser
{
UserId = Guid.NewGuid().ToString(),
Username = username
};
try
{
await _blogDbService.CreateUserAsync(user);
m.Message = $"User has been created.";
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.Conflict)
{
//item already existed. Optimize for the success path.
ModelState.AddModelError("", $"User with the username {username} already exists.");
}
return(View(m));
}
//[Authorize(Roles = "Administrator")]
public async Task <IActionResult> RegisterAsync(AccountRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User {
FullName = model.FullName, Email = model.Email, Tel = model.Tel, UserName = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, model.Role);
TempData["StatusMessage"] = "New account created successfully";
return(RedirectToAction("Register"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
model.UserRoles = GetRolesDropdown();
}
}
return(View(model));
}
public IActionResult Register(AccountRegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
FisrtName = registerViewModel.FisrtName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
var createTask = _userManager.CreateAsync(user, registerViewModel.Password);
if (createTask.Result.Succeeded)
{
_messageSender.SendMessage(email: registerViewModel.Email,
nameTo: registerViewModel.FisrtName,
messageText: "You have been registered on the site FootballShow");
return(RedirectToRoute(new { controller = "Home", action = "Index" }));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public ActionResult Login(string username, string password)
{
string result = accountService.CheckLogin(username, password);
if (result == null)
{
//login k thành công
var viewModel = new AccountRegisterViewModel
{
InvalidLogin = "******"
};
return(View("~/Views/Home/login.cshtml", viewModel));
}
Session["CURRENT_USER_ID"] = result;
//merge cart if user
int roleId = Convert.ToInt32(Session.GetCurrentUserInfo("RoleId"));
if (roleId == 2)
{
bool resultMerge = shoppingService.MergeCartSessionAnddDDB(Session.GetCurrentUserInfo("Username"));
if (resultMerge) //done => remove cart in session
{
Session["CART"] = null;
}
}
return(Redirect(Request.UrlReferrer.ToString()));
}
public IActionResult Register([FromQuery] MessageType messageType, AccountRegisterViewModel account)
{
//Inserted user account
//User: [email protected]
//Pass: Z123456z*
if (ModelState.IsValid)
{
var user = new IdentityUser()
{
Email = account.Email,
UserName = account.Email,
};
Task <IdentityResult> task = _userManager.CreateAsync(user, account.Password);
if (task.Result.Succeeded)
{
_signInManager.SignInAsync(user, false);
MessageService.SendMessage(account.Email, messageType);
return(RedirectToAction("Index", "Human"));
}
task.Result
.Errors
.ToList()
.ForEach(x => ModelState.AddModelError(x.Code, x.Description));
}
return(View());
}
public async Task <IActionResult> Create([FromBody] AccountRegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(v => v.Errors).Select(modelError => modelError.ErrorMessage).ToList()));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.Select(x => x.Description).ToList()));
}
var adminRole = await _roleManager.FindByNameAsync("Admin");
if (adminRole == null)
{
adminRole = new IdentityRole("Admin");
await _roleManager.CreateAsync(adminRole);
await _roleManager.AddClaimAsync(adminRole, new Claim("ListenThen", "Get"));
}
if (!await _userManager.IsInRoleAsync(user, adminRole.Name))
{
await _userManager.AddToRoleAsync(user, adminRole.Name);
}
return(Ok());
}
public async Task <ActionResult> Register(AccountRegisterViewModel viewModel)
{
// If the ModelState is valid...
if (ModelState.IsValid)
{
// Instantiate a User object
var user = new User()
{
UserName = viewModel.Email, Email = viewModel.Email
};
// Create the user
var result = await _userManager.CreateAsync(user, viewModel.Password);
// If the user was successfully created...
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// Sign-in the user and redirect them to the web app's Home page
return(RedirectToAction("Index", "Entries"));
}
// If there were errors...
foreach (var error in result.Errors)
{
// Add model errors
ModelState.AddModelError("", error);
}
}
return(View(viewModel));
}
public async Task <IActionResult> Register(AccountRegisterViewModel vm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = vm.Email,
Email = vm.Email
};
// adds a new user with the password to the database
var result = await userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
// signs in new user without using persistent cookie. When
// browser is closed, user is auto-logged out.
await signInManager.SignInAsync(user, false);
// forwards newly registered user to Index
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(vm));
}
public IActionResult Register(AccountRegisterViewModel viewModel, [FromServices] IMessageSender messageSender)
{
if (ModelState.IsValid)
{
var user = new User
{
UserName = viewModel.Email,
Email = viewModel.Email,
FirstName = viewModel.FirstName,
LastName = viewModel.LastName
};
var createTask = _userManager.CreateAsync(user, viewModel.Password);
if (createTask.Result.Succeeded)
{
// Send an email with this link
string code = _userManager.GenerateEmailConfirmationTokenAsync(user).Result;
var emailConfirmationUrl = Url.Action(nameof(ConfirmEmail), "Account",
new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
messageSender.SendConfirmationMessage(user, emailConfirmationUrl);
return(RedirectToAction(nameof(SuccessRegistration)));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public async Task <ActionResult> Index(AccountRegisterViewModel viewModel)
{
//If the ModelState is valid...
if (ModelState.IsValid)
{
//Instantiate a UserLogin object
var user = new UserLogin {
UserName = viewModel.Username
};
//Create the user
var result = await _userManager.CreateAsync(user, viewModel.Password);
//If the user was successfuly created...
if (result.Succeeded)
{
return(RedirectToAction("Index", "Account"));
}
//If there were errors...
//Add model errors
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
return(View(viewModel));
}
public IActionResult Register(AccountRegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
FisrtName = registerViewModel.FisrtName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
var createTask = _userManager.CreateAsync(user, registerViewModel.Password);
if (createTask.Result.Succeeded)
{
return(RedirectToRoute(new { controller = "Home", action = "Index" }));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public void AccountController_Register_CreateCalledOnce()
{
//Arrange
Mock <UserManager <ApplicationUser> > userManager = new Mock <UserManager <ApplicationUser> >();//Нужно добавить все зависимости в конструктор
Mock <SignInManager <ApplicationUser> > signInManager = new Mock <SignInManager <ApplicationUser> >();
var registerViewModel = new AccountRegisterViewModel
{
FirstName = "TestFirstName",
LastName = "TestLastName",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var user = new ApplicationUser
{
FirstName = registerViewModel.FirstName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.Email,
Email = registerViewModel.Email
};
userManager.Setup(x => x.CreateAsync(user, registerViewModel.Password)).ReturnsAsync(IdentityResult.Success);
AccountController controller = new AccountController(userManager.Object, signInManager.Object);
//Act
controller.Register(registerViewModel);
//Assert
userManager.Verify(x => x.CreateAsync(user, registerViewModel.Password), Times.Once);
}
