public ActionResult CreateAccount(CreateAccountViewModel viewModel) { if (!ModelState.IsValid) { return(View(viewModel)); } string error; if (!Recapcha.ValidateCapcha(Request, Request.Form["recaptcha_challenge_field"], Request.Form["recaptcha_response_field"], out error)) { viewModel.CapchaError = error; return(View(viewModel)); } MembershipCreateStatus status; var user = Membership.CreateUser(viewModel.Username, viewModel.Password, viewModel.Email, null, null, true, null, out status); if (status != MembershipCreateStatus.Success) { return(View(viewModel)); } user.LastActivityDate = DateTime.Now; FormsAuthentication.SetAuthCookie(viewModel.Username, viewModel.RememberMe); return(RedirectToAction("Index", "Web")); }
public ActionResult RegisterSave(CreateAccountViewModel model) { if (ModelState.IsValid) { ApplicationUser user = new ApplicationUser { UserName = model.Name, Email = model.Email }; IdentityResult result = UserManager.Create(user, model.Password); if (result.Succeeded) { UserManager.AddToRole(user.Id, "User"); ClaimsIdentity ident = UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);// CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthManager.SignOut(); AuthManager.SignIn( new AuthenticationProperties { IsPersistent = false }, ident); return(RedirectToAction("Index", "PeoplesAward")); } else { AddErrorsFromResult(result); } } ViewBag.Title = "Регистрация пользователя"; return(View("Register", model)); }
public ActionResult CreateAccount(CreateAccountViewModel viewModel) { LocalAuthenticationController.RequireLocalAuthMode(); if (!ModelState.IsValid) { return(ViewCreateAccount(viewModel)); } var theSelectedOrganization = HttpRequestStorage.DatabaseEntities.Organizations.GetOrganization(viewModel.OrganizationID); Check.EnsureNotNull(theSelectedOrganization); var existingUser = HttpRequestStorage.DatabaseEntities.People.GetPersonByEmail(viewModel.Email, false); if (existingUser != null) { SetMessageForDisplay($"{existingUser.GetFullNameFirstLastAndOrgAsUrl(CurrentFirmaSession)} already has an account."); return(RedirectToAction(new SitkaRoute <UserController>(x => x.Detail(existingUser)))); } var newUser = CreateNewFirmaPersonWithoutKeystone(theSelectedOrganization, viewModel); HttpRequestStorage.DatabaseEntities.SaveChanges(); var saltAndHash = PBKDF2PasswordHash.CreateHash(viewModel.Password); var personLoginAccount = new PersonLoginAccount(newUser, newUser.Email, DateTime.Now, saltAndHash.PasswordHashed, saltAndHash.PasswordSalt, true, 0, 0); HttpRequestStorage.DatabaseEntities.AllPersonLoginAccounts.Add(personLoginAccount); HttpRequestStorage.DatabaseEntities.SaveChanges(); SetMessageForDisplay($"{newUser.GetFullNameFirstLastAndOrgAsUrl(CurrentFirmaSession)} successfully added. You may want to assign them a role."); return(RedirectToAction(new SitkaRoute <UserController>(x => x.Detail(newUser)))); }
public ActionResult CreateAccount() { LocalAuthenticationController.RequireLocalAuthMode(); var viewModel = new CreateAccountViewModel(); return(ViewCreateAccount(viewModel)); }
private ActionResult ViewCreateAccount(CreateAccountViewModel viewModel) { var firmaPage = FirmaPageTypeEnum.InviteUser.GetFirmaPage(); var viewData = new CreateAccountViewData(CurrentFirmaSession, firmaPage); return(RazorView <CreateAccount, CreateAccountViewData, CreateAccountViewModel>(viewData, viewModel)); }
public async Task <IActionResult> Register([FromBody] CreateAccountViewModel model) { var existingUser = await context.Users.FirstOrDefaultAsync(u => u.Email == model.Email || u.UserName == model.Username); if (existingUser != null) { return(Ok("User already exists.")); } User user = new User { Email = model.Email, UserName = model.Username }; var newUser = await userManager.CreateAsync(user); if (!newUser.Succeeded) { return(Ok("Error: Could not create user.")); } newUser = await userManager.AddPasswordAsync(user, model.Password); await signInManager.SignInAsync(user, isPersistent : false); return(Ok("User successfully created!")); }
public ActionResult Create(CreateAccountViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Username, Email = model.Email }; bool b = true; try { UserManager.Create(user, model.Password); } catch (Exception e) { b = false; Console.WriteLine(e); } if (b) { AssignRoleTo(UserManager, Guid.Parse(user.Id), "User"); return(RedirectToAction("ListUsers")); } } return(View(model)); }
public async Task <CommandResult <Guid> > CreateAdmin([FromBody] CreateAccountViewModel accountViewModel) { var createAccountCommandModel = _mapper.Map <AccountModel>(accountViewModel); createAccountCommandModel.AccountRole = AdministratorRoles.Admin_Role; return(await _accountManager.CreateAccount(createAccountCommandModel)); }
public IActionResult Create(CreateAccountViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var account = new Account( userID: UserID, name: model.Name, type: model.Type.Value, startingBalance: model.StartingBalance.Value, isMainAccount: model.IsMainAccount, isIncludedInNetWorth: model.IncludeInNetWorth, isDormant: false, displayOrder: model.DisplayOrder.Value, numberLast4Digits: model.NumberLast4Digits ); Db.InsertOrUpdate(account); UnitOfWork.CommitChanges(); return(RedirectToAction(nameof(Index))); }
public IActionResult Create(CreateAccountViewModel viewModel) { // If basic syntax check returns false return to view with proper messages // defined in view model annotations. if (!ModelState.IsValid) { return(View()); } Profile addedProfile = UserAccountServiceLogic.CreateProfile(viewModel); User addedUser = addedUser = UserAccountServiceLogic.CreateUser(viewModel, addedProfile); addedProfile.User = addedUser; if (UserAccountServiceLogic.AddUserAndDependenciesToDB(addedUser, userManager, viewModel, context).Result) { ViewBag.Message = localizer["CreateSuccess"]; return(RedirectToAction("Login")); } else { ViewBag.Message = localizer["CreateFail"]; return(View()); } }
public ActionResult CreateAccount(CreateAccountViewModel NewAccount) { if (NewAccount.IsAccountNameExist()) { return(View(NewAccount)); } if (!NewAccount.IsInputPwIdentity()) { return(View(NewAccount)); } MemberUser MemAccount = new MemberUser(); MemAccount.UserLastName = NewAccount.UserLastName; MemAccount.UserFirstName = NewAccount.UserFirstName; MemAccount.UserEmail = NewAccount.UserEmail; MemAccount.AccountName = NewAccount.AccountName; NewAccount.EncryptPw(); MemAccount.AccountPassword = NewAccount.EncryptPassword; db.MemberUsers.Add(MemAccount); db.SaveChanges(); return(RedirectToAction("Index", "User")); }
public async Task <IActionResult> Create(CreateAccountViewModel model) { if (!ModelState.IsValid) { return(View(model)); } try { var cred = new NexusUserCredential { Username = model.Username, Password = model.Password, Pin = model.Pin }; await _userManager.CreateAccount(HttpContext, cred, model.AutoLogin); return(RedirectToAction("index", "node")); } catch (Exception e) { ModelState.AddModelError("summary", e.Message); return(View(model)); } }
public IActionResult Create(CreateAccountViewModel model) { if (ModelState.IsValid) { Account account = new Account { UserGuid = userManager.GetUserId(User), BankName = model.BankName, AccountName = model.AccountName, AccountNumber = model.AccountNumber, CardNumber = model.CardNumber, Credit = Convert.ToInt64(model.Credit) }; context.Account.Add(account); if (Convert.ToBoolean(context.SaveChanges())) { TempData["ToasterState"] = ToasterState.Success; TempData["ToasterType"] = ToasterType.Message; TempData["ToasterMessage"] = Messages.CreateAccountSuccessful; } else { TempData["ToasterState"] = ToasterState.Error; TempData["ToasterType"] = ToasterType.Message; TempData["ToasterMessage"] = Messages.CreateAccountFailed; } return(RedirectToAction("Index")); } return(BadRequest()); }
public ActionResult CreateSavings([Bind(Include = "AccountName,BranchID,CustomerID")] CreateAccountViewModel model) { ViewBag.BranchID = new SelectList(db.Branches, "ID", "Name", model.BranchID); if (ModelState.IsValid) { try { CustomerAccount customerAccount = new CustomerAccount(); customerAccount.AccountName = model.AccountName; customerAccount.AccountType = AccountType.Savings; customerAccount.CustomerID = model.CustomerID; customerAccount.AccountNumber = custActLogic.GenerateCustomerAccountNumber(AccountType.Savings, model.CustomerID); customerAccount.DateCreated = DateTime.Now; customerAccount.BranchID = model.BranchID; customerAccount.AccountStatus = AccountStatus.Closed; customerAccount.AccountBalance = 0; db.CustomerAccounts.Add(customerAccount); db.SaveChanges(); return(RedirectToAction("Index")); } catch (Exception ex) { AddError(ex.ToString()); return(View(model)); } } AddError("Please enter valid data"); return(View(model)); }
public async Task <IActionResult> CreateAccount([FromBody] CreateAccountViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await _userService.CreteUserAsync(model.Email, model.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } var token = await _userService.JwtLogin(model.Email, model.Password); if (token != null) { return(new JsonResult(new TokenResponseViewModel { AccessToken = new JwtSecurityTokenHandler().WriteToken(token), ExpiresIn = token.ValidTo })); } return(BadRequest()); }
public async Task CreateAccount(CreateAccountViewModel vm) { var(password, salt) = _passwordProtectionService.Encrypt(vm.PlainTextPassword); if (!vm.IsAdmin) { var customer = new Customer { FullName = vm.FullName, PhoneNumber = vm.PhoneNumber, Account = new Account { Salt = salt, AccountType = AccountTypes.Standard, Password = password, Username = vm.Username } }; await _customerRepository.AddAysnc(customer); await _customerRepository.SaveAsync(); return; } var account = new Account { Username = vm.Username, AccountType = AccountTypes.Admin, Password = password, Salt = salt }; await _accountRepository.AddAysnc(account); await _accountRepository.SaveAsync(); }
public IActionResult CreateWithRole() { var model = new CreateAccountViewModel { Roles = new List <SelectListItem> { new SelectListItem { Text = "Client", Value = "Client" }, new SelectListItem { Text = "Secretary", Value = "Secretary" }, new SelectListItem { Text = "Mechanic", Value = "Mechanic" }, new SelectListItem { Text = "Admin", Value = "Admin" }, }, Specialties = _specialtyRepository.GetComboSpecialty() }; return(View(model)); }
public void Create_Post_Error() { // arrange var mockAuthenticationService = new Mock <IAuthenticationService>(); var mockAccountService = new Mock <IAccountService>(); mockAccountService .Setup(m => m.CreateAccount(It.IsAny <CreateAccountRequest>())) .Returns(new CreateAccountResponse { Success = false }); var controller = new AccountController(mockAccountService.Object, mockAuthenticationService.Object, null); var model = new CreateAccountViewModel(); // act var result = controller.Create(model) as ViewResult; // assert Assert.IsNotNull(result); Assert.AreEqual(string.Empty, result.ViewName); Assert.IsFalse(result.ViewData.ModelState.IsValid); Assert.AreEqual(1, result.ViewData.ModelState.Count); }
/// <summary> /// Create an account from the view. /// </summary> /// <param name="createAccountViewModel"> The create account view model. </param> /// <param name="linkToHome"> The link To Home. </param> /// <returns> The <see cref="CreateAccountViewModel"/>. </returns> public CreateAccountViewModel CreateAccount(CreateAccountViewModel createAccountViewModel, Uri linkToHome) { // Convert the given View Model to the coresponding data model var userToCreate = this.userConversions.ConvertCreateAccountViewModelToUser(createAccountViewModel); // Set up the credentials with a hashed password. userToCreate.UserCredential = new UserCredential { UserName = createAccountViewModel.UserName, PasswordHash = PasswordHash.HashPassword(PasswordHash.CreateSalt(createAccountViewModel.UserName.ToLower()), createAccountViewModel.Password) }; userToCreate.IsActive = true; userToCreate.Contact = new Contact(); // Create the user in the database. var createdUser = this.userRepo.CreateUser(userToCreate); var userView = this.userConversions.ConvertUserToCreateAccountViewModel(createdUser); if (userView != null) { var email = new AccountCreatedEmail(userView.UserName, userView.UserType); email.Send(linkToHome); } // Return the corresponding view model return(userView); }
public async Task <Object> CreateAccount(CreateAccountViewModel model) { Account account = new Account(); account.Username = model.Username; if (account.Username.Length == 0) { return(_apiResponse.Error(ShoerserException.AccountException.A03, nameof(ShoerserException.AccountException.A03))); } account.FullName = model.FullName; if (account.FullName.Length == 0) { return(_apiResponse.Error(ShoerserException.AccountException.A04, nameof(ShoerserException.AccountException.A04))); } account.Password = model.Password; account.Address = model.Address; account.Role = model.Role; if (!account.Role.Equals(Role.Admin) && !account.Role.Equals(Role.Moderator) && !account.Role.Equals(Role.Customer)) { return(_apiResponse.Error(ShoerserException.AccountException.A06, nameof(ShoerserException.AccountException.A06))); } account.CreatedAt = DateTime.Now; _unitOfWork.AccountRepository.Add(account); var result = _apiResponse.Ok(_unitOfWork.Save()); return(result); }
public ActionResult Register(CreateAccountViewModel viewModel) { var validRes = ValidateRegistration(viewModel.Email, viewModel.Password, viewModel.ConfirmPassword, viewModel.Name); if (!validRes.IsValid) { TempData[RegistrationValidationSummaryKey] = validRes.ValidationSummary; return(this.RedirectLocal("~/Login")); } var user = _teeyootMembershipService.CreateUser(viewModel.Email, viewModel.Password, viewModel.Name, viewModel.Phone); if (user == null) { return(this.RedirectLocal("~/Login")); } _teeyootUserService.SendWelcomeEmail(user); _authenticationService.SignIn(user, false); return(string.IsNullOrEmpty(viewModel.ReturnUrl) ? Redirect("~/") : this.RedirectLocal(viewModel.ReturnUrl)); }
public async Task <IActionResult> CreateAccount([FromBody, BindRequired] CreateAccountViewModel model) { if (!ModelState.IsValid) { return(BadRequest(new { Error = "Invalid request" })); } if (!await userManager.UserIsInRole(User.Claims.First(f => f.Type == ClaimTypes.NameIdentifier).Value, "acct-managers")) { return(Forbid()); } var user = new ApplicationUser { UserName = model.Username, Email = model.Email, EmailConfirmed = true, MemberId = model.MemberId, LockoutEnabled = true, Created = DateTimeOffset.Now }; var result = await userManager.CreateAsync(user); await userManager.AddClaimAsync(user, new Claim("name", model.Name)); return(Ok(new { Data = new AccountInfo { Id = user.Id, Username = user.UserName, Email = user.Email, Name = (await userManager.GetClaimsAsync(user)).FirstOrDefault(c => c.Type == "name")?.Value } })); }
public async Task <ActionResult> Create(CreateAccountViewModel account) { ApplicationUserManager userManager = HttpContext.GetOwinContext().Get <ApplicationUserManager>(); if (ModelState.IsValid) { var user = new User { UserName = account.NewUser.UserName, Email = account.NewUser.Email, FirstName = account.NewUser.FirstName, LastName = account.NewUser.LastName, PhoneNumber = account.NewUser.PhoneNumber, OrganizationalUnitID = account.NewUser.OrganizationalUnitID }; var result = await userManager.CreateAsync(user, account.Password); if (result.Succeeded) { foreach (var role in account.RolesNames) { userManager.AddToRole(user.Id, role); } return(RedirectToAction("Index", "Users")); } AddErrors(result); } // Dotarcie do tego miejsca wskazuje, że wystąpił błąd, wyświetl ponownie formularz account.AllRoles = db.Roles.ToList(); ViewBag.UnitIDs = new SelectList(db.OrganizationalUnits, "OrganizationalUnitID", "UnitName", account.NewUser.OrganizationalUnitID); return(View(account)); }
public ActionResult CreateAdministrator(CreateAccountViewModel viewModel) { if (Membership.GetAllUsers().Count != 0) // This page is only accessible with no registered users in the db { return(new HttpUnauthorizedResult()); } if (!ModelState.IsValid) { return(View(viewModel)); } MembershipCreateStatus status; var user = Membership.CreateUser(viewModel.Username, viewModel.Password, viewModel.Email, null, null, true, null, out status); if (status != MembershipCreateStatus.Success) { return(View(viewModel)); } user.LastActivityDate = DateTime.Now; if (!Roles.GetAllRoles().Contains("Administrator")) { Roles.CreateRole("Administrator"); } Roles.AddUserToRole(viewModel.Username, "Administrator"); FormsAuthentication.SetAuthCookie(viewModel.Username, viewModel.RememberMe); return(RedirectToAction("Index", "Web")); }
public ActionResult CreateAccount(CreateAccountViewModel createAccountViewModel) { bool isAccountCreated = false; try { isAccountCreated = identityService.CreateAccount(createAccountViewModel); } catch (Exception ex) { ModelState.AddModelError(string.Empty, localizationManager.GetLocalizedString(ex.Message)); } if (isAccountCreated) { AuthenticationResult result = LogIn(createAccountViewModel.Email, createAccountViewModel.Password, false); if (result.IsSuccess) { return(authenticationManager.RedirectFromLoginPage(createAccountViewModel.Email)); } } //SetAllCountries(createAccountViewModel); return(View(createAccountViewModel)); }
public IActionResult CheckUsername(CreateAccountViewModel viewModel) { HttpContext.Session.SetString(UsernameSession, _accountLogic.CheckUsername(viewModel.Account.UserName).ToString()); var ajaxError = new AJAXError(HttpContext.Session.GetString(UsernameSession), "#usernameError"); return(new JsonResult(JsonConvert.SerializeObject(ajaxError))); }
public ActionResult Create(CreateAccountViewModel model) { if (model == null) { return(View("Error", "", Resources.NullArgument)); } if (!ModelState.IsValid) { return(View("Create")); } try { var user = userService.Create(model.FirstName, model.LastName, model.Passport, model.Email); var account = accountService.OpenAccount(model.AccountType, user.Id); return(View("CreateSuccess", account)); } catch (Exception e) { return(View("Error", "", e.Message)); } }
public IActionResult CreateAccount(CreateAccountViewModel model) { if (model == null) { throw new ArgumentNullException(nameof(model)); } ValidateCreateAccountModel(ref model); if (ModelState.IsValid) { if (_accountProvider.CreateAccount(model.Email, model.FirstName, model.Surname, model.Password, model.Telephone, model.BusinessName, model.AddressLine1, model.AddressLine2, model.AddressLine3, model.City, model.County, model.Postcode, model.Country, out Int64 userId)) { UserSession session = GetUserSession(); if (session != null) { session.Login(userId, $"{model.FirstName} {model.Surname}", model.Email); } return(Redirect("/Account/")); } } PrepareCreateAccountModel(ref model); return(View(model)); }
public ActionResult CreateAccount(CreateAccountViewModel vm) { using (var client = new UserProfileServiceReference.UserProfileServiceClient()) { var newUser = new UserProfileServiceReference.NewUser() { Email = vm.email, FirstName = vm.firstname, Surname = vm.surname, Password = vm.password, Username = vm.username, }; var user = client.CreateUser(newUser); if (user != null) { Session["AuthorizedAsUser"] = "******"; Session["UserId"] = client.GetUserByUserName(vm.username).Id; } } if (Session["AuthorizedAsUser"] == "true") { return(View("UpdateProfile")); } else { return(View("Index")); } }
public ActionResult CreateAccount(CreateAccountViewModel model) { string socialNetwork = Request.QueryString["socialNetwork"]; string token = Request.QueryString["at"]; string secret = Request.QueryString["as"]; string twitterUserId = Request.QueryString["uid"]; if (ModelState.IsValid) { MembershipCreateStatus createStatus = _membershipService.CreateUser(model.Email, model.Password, model.UserName, socialNetwork, token, secret, model.FirstName, model.LastName, model.FacebookId, model.TwitterId, model.Gender, model.City, model.State, model.locale); if (createStatus == MembershipCreateStatus.Success) { string ticket = _membershipService.GetAuthTicketFromEmail(model.Email); _authenticationService.LogIn(ticket: ticket, createPersistentCookie: true); return(RedirectToAction("Index", "Browse")); } else { ModelState.AddModelError("", ValidationHelpers.AccountValidation.ErrorCodeToString(createStatus)); } } //If error occured during account creation return to the registration page with model errors displayed if (socialNetwork == "Facebook") { return(View("RegisterWithFacebook", model)); } else { return(View("CreateAccount", model)); } }
public async Task<IActionResult> Create(CreateAccountViewModel request) { var result = await _mediator.SendAsync(request); if (!result.Succeeded) { AddErrorsToModelState(result); return RedirectToAction("Create"); } return RedirectToAction("Index"); }
public ActionResult Create(CreateAccountViewModel model) { if (this.ModelState.IsValid) { var request = new CreateAccountRequest { UserName = model.UserName, Password = model.Password, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName }; var response = this.accountService.CreateAccount(request); if (response.Status == StatusCode.OK) { var messageResponse = this.SendActivateAccountToken(model.Email, response.ActivateAccountToken, model.FirstName, model.LastName); if (messageResponse.Status == StatusCode.OK) { this.TempData["SuccessMessage"] = "You have successfully created a new account. An activation code has been sent to you by email. When you receive the this email, click on the link to activate your account."; return this.RedirectToAction("LogIn"); } else { this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError); } } else if (response.Status == StatusCode.BadRequest) { this.ModelState.AddModelError(string.Empty, $"Your account was not created for the following reason: {this.GetErrorMessage(response.CreateAccountStatus)}"); } else { this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError); } } return this.View(); }
public AccountIndexViewModel(CreateAccountViewModel createAccountViewModel, LogOnViewModel logOnViewModel) { CreateAccountViewModel = createAccountViewModel; LogOnViewModel = logOnViewModel; }
public void Create_Post_InternalServerErrror() { // arrange var mockAuthenticationService = new Mock<IAuthenticationService>(); var mockAccountService = new Mock<IAccountService>(); mockAccountService.Setup(m => m.CreateAccount(It.IsAny<CreateAccountRequest>())) .Returns(new CreateAccountResponse { Status = StatusCode.InternalServerError }); var controller = new AccountController(mockAuthenticationService.Object, mockAccountService.Object, null); var model = new CreateAccountViewModel(); // act var result = controller.Create(model) as ViewResult; // assert Assert.IsNotNull(result); Assert.AreEqual(string.Empty, result.ViewName); Assert.IsFalse(result.ViewData.ModelState.IsValid); Assert.AreEqual(1, result.ViewData.ModelState.Count); }
public void Create_Post_BadRequest() { // arrange var mockAuthenticationService = new Mock<IAuthenticationService>(); var mockAccountService = new Mock<IAccountService>(); mockAccountService.Setup(m => m.CreateAccount(It.IsAny<CreateAccountRequest>())) .Returns(new CreateAccountResponse { Status = StatusCode.BadRequest }); var controller = new AccountController(mockAuthenticationService.Object, mockAccountService.Object, null); var model = new CreateAccountViewModel { Email = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; // act var result = controller.Create(model) as ViewResult; // assert Assert.IsNotNull(result); Assert.AreEqual(string.Empty, result.ViewName); Assert.IsFalse(result.ViewData.ModelState.IsValid); Assert.AreEqual(1, result.ViewData.ModelState.Count); }
public void Create_Post_OK() { // arrange var mockAuthenticationService = new Mock<IAuthenticationService>(); var mockAccountService = new Mock<IAccountService>(); mockAccountService.Setup(m => m.CreateAccount(It.IsAny<CreateAccountRequest>())) .Returns(new CreateAccountResponse { Status = StatusCode.OK, ActivateAccountToken = "YYYYYYYYYYYY", CreateAccountStatus = CreateAccountStatus.Success }); var mockMessagingService = new Mock<IMessageService>(); var controller = new AccountController(mockAuthenticationService.Object, mockAccountService.Object, mockMessagingService.Object); //controller.Url = new UrlHelper( // new RequestContext(this.mockContext.Object, new RouteData()), // new RouteCollection() //); // mock url needed to mock the call to Url.Action //var mockUrl = new Mock<UrlHelper>(); //mockUrl.Setup(x => x.Action("ActivateAccount", "Email", new { name = "FirstName", token = "token" })).Returns("/email/activateaccount?name=XXX&token=YYY"); //controller.Url = mockUrl.Object; var model = new CreateAccountViewModel { Email = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; // act var result = controller.Create(model) as RedirectToRouteResult; // assert Assert.IsNotNull(result); Assert.AreEqual("LogIn", result.RouteValues["action"]); Assert.AreEqual(null, result.RouteValues["controller"]); Assert.IsNotNull(controller.TempData["SuccessMessage"]); }