public UpdateUser GetUser(int Id) { UpdateUser userData = new UpdateUser(); string connStr = WebConfigurationManager.ConnectionStrings["tdlConnection"].ToString(); using (SqlConnection conn = new SqlConnection(connStr)) { string query = "SELECT * FROM Users WHERE user_id = @Id"; using (SqlCommand cmd = new SqlCommand(query, conn)){ conn.Open(); cmd.Parameters.AddWithValue("@Id", Id); SqlDataReader reader = cmd.ExecuteReader(); reader.Read(); userData.user_id = Convert.ToInt16(reader["user_id"]); userData.first_name = Convert.ToString(reader["first_name"]); userData.last_name = Convert.ToString(reader["last_name"]); userData.email = Convert.ToString(reader["email"]); userData.password = Convert.ToString(reader["password"]); } } return(userData); }
public void Handle(UpdateUser update) { if (update.User.Id == CacheService.Options.MyId) { _lifetimeService.Update(); } }
public void should_update_an_existing_user() { var existingUser = new User(); Save(existingUser); var updateUser = new UpdateUser { Id = existingUser.Id, Username = "******", EmailAddress = "f", Name = "fo", Password = "******", }; User user = null; WithDbContext(context => user = GetInstance<UpdateUserHandler>().Handle(updateUser)); WithDbContext(context => { var foundUser = context.Find<User>(user.Id); foundUser.ShouldNotBeNull(); Compare(foundUser, user); }); }
private static async Task AttemptUpdateDuplicate( HttpClient client, string token) { var command = new UpdateUser( null, new UserUpdate(Username: UniqueUsername)); await SendCommand( client, command, "/api/user", method : HttpMethod.Put, headers : new Dictionary <string, string> { { "Authorization", $"Bearer {token}" } }, expectedResponseCode : HttpStatusCode.Conflict); command = new UpdateUser(null, new UserUpdate(Email: UniqueEmail)); await SendCommand( client, command, "/api/user", method : HttpMethod.Put, headers : new Dictionary <string, string> { { "Authorization", $"Bearer {token}" } }, expectedResponseCode : HttpStatusCode.Conflict); }
public void should_create_a_new_user() { var updateUser = new UpdateUser { Username = "******", EmailAddress = "f", Name = "fo", Password = "******" }; User user=null; WithDbContext(context => user= GetInstance<UpdateUserHandler>().Handle(updateUser)); WithDbContext(context => { var foundUser = context.Find<User>(user.Id); foundUser.ShouldNotBeNull(); var compare = new KellermanSoftware.CompareNetObjects.CompareObjects(); // savedJob is a proxy compare.MaxDifferences = 1; compare.Compare(user, foundUser); }); }
private static void ApplyUpdateToModel(UpdateUser request, IUserAuth updated) { updated.UserName = request.UserName; updated.DisplayName = request.DisplayName; updated.Email = request.Email; updated.Roles = request.Roles.Where(r => r.IsMemberOf).Select(r => r.Id).ToList(); }
public IActionResult AuthorizationAdmin([FromBody] UpdateUser user) { if (_check.CheckUserLogin() == false) { return(RedirectToAction("Index", "Login")); } if (user.isChecked == "yes") { User tempuser = _repositoryUser.GetUser((int)user.Userid); if (tempuser != null) { tempuser.Level = 1; _logger.WriteLog($"User : {tempuser.UserName} , Updated To Admin Level", Catgory.User); _repositoryUser.SaveUsers(); } return(RedirectToAction("Index", "Home")); } else { User tempuser = _repositoryUser.GetUser((int)user.Userid); if (tempuser != null) { tempuser.Level = 0; _repositoryUser.SaveUsers(); } } return(View("index", "Admin")); }
public async Task <IActionResult> Update(string username, [FromBody] UpdateUser model) { var userToUpdate = await userManager.FindByNameAsync(username); var user = Request.HttpContext.User; if (userToUpdate == null) { return(StatusCode(StatusCodes.Status400BadRequest, new StatusResponse { Status = "Error", Message = "" })); } if (user.Identity.Name != userToUpdate.UserName && user.Claims.Where(s => s.Type == typeSchema).Any(s => s.Value == "Admin") == false) { return(StatusCode(StatusCodes.Status401Unauthorized, new StatusResponse { Status = "Error", Message = "Unathorized to update this user!" })); } var mappedResult = mapper.Map <UpdateUser, Account>(model, userToUpdate); var result = await userManager.UpdateAsync(mappedResult); if (!result.Succeeded) { return(StatusCode(StatusCodes.Status500InternalServerError, new StatusResponse { Status = "Error", Message = "User update failed! Please check user details and try again." })); } return(Ok(new StatusResponse { Status = "Success", Message = "User updated successfully!" })); }
public IActionResult UpdateProfile([FromBody] UpdateUser user) { System.Diagnostics.Debug.WriteLine($"{user.Email} {user.FirstName} {user.SecondName} {user.LastName} {user.Roles}"); var u = _userManager.GetByEmail(user.Email); if (u != null) { if (u.FirstName != user.FirstName) { _logger.LogInformation($"User[{u.Email}], Changed FirstName: [{u.FirstName}] -> [{user.FirstName}] |"); u.FirstName = user.FirstName; } if (u.SecondName != user.SecondName) { _logger.LogInformation($"User[{u.Email}], Changed SecondName: [{u.SecondName}] -> [{user.SecondName}] |"); u.SecondName = user.SecondName; } if (u.LastName != user.LastName) { _logger.LogInformation($"User[{u.Email}], Changed LastName: [{u.LastName}] -> [{user.LastName}] |"); u.LastName = user.LastName; } var rolesBefore = _roleManager.GetAllRolesByUserId(u.Id); _userManager.RemoveFromRoles(u.Email, rolesBefore.ToList()); var rolesAfter = user.Roles; _userManager.AddToRoles(u.Email, rolesAfter.ToList()); rolesAfter = _roleManager.GetAllRolesByUserId(u.Id); _userManager.UpdateUser(u); return(Ok()); } return(BadRequest(new { message = "No such user." })); }
public UserControllerTests() { // Initializate data on start _existingUser = new CreateUser { Email = "*****@*****.**", FirstName = "exist", LastName = "exist", Password = "******" }; _existingUserForDelete = new CreateUser { Email = "*****@*****.**", FirstName = "existForDetele", LastName = "existForDetele", Password = "******" }; _nonExistingUser = new UpdateUser { Email = "*****@*****.**", FirstName = "Non existing user name", LastName = "Non existing user name", Password = "******" }; RegisterUserAsync(_existingUser); RegisterUserAsync(_existingUserForDelete); }
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser() { var options = this.CreateNewContextOptions(); const string userId = "12345"; const string firstName = "changed"; var message = new UpdateUser { User = new ApplicationUser { Id = userId, FirstName = firstName } }; using (var context = new AllReadyContext(options)) { context.Users.Add(new ApplicationUser { Id = userId, FirstName = "notChanged" }); await context.SaveChangesAsync(); } using (var context = new AllReadyContext(options)) { var sut = new UpdateUserHandler(context); await sut.Handle(message); } using (var context = new AllReadyContext(options)) { var user = context.Users.FirstOrDefault(u => u.Id == userId); Assert.NotNull(user); Assert.Equal(user.FirstName, firstName); } }
public async Task <SuccessResponse> UpdateAsync <T>(string id, User <T> user, bool autoName = true, bool destructive = false) { Ensure.ArgumentNotNull(user, nameof(user)); var additionalParams = new Dictionary <string, string>(); additionalParams.Add("auto_name", autoName.ToString().ToLowerInvariant()); var updateUser = new UpdateUser <T> { Email = user.Email, FirstName = user.FirstName, LastName = user.LastName, Name = user.Name, Profile = user.Profile, Username = user.Username }; if (destructive) { return(await HttpConnection.PutAsync <SuccessResponse>($"/users/{id}", updateUser, additionalParams)); } else { return(await HttpConnection.PatchAsync <SuccessResponse>($"/users/{id}", updateUser, additionalParams)); } }
public async Task <Guid> Handle(UpdateUser message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } var user = await _userManager.FindByIdAsync(message.Id); user.FirstName = message.FirstName; user.LastName = message.LastName; user.Email = message.Email; user.PhoneNumber = message.PhoneNumber; if (message.IsAdministrator) { if (user.Roles.Contains(Roles.OrganizationAdministrator) == false) { user.Roles.Add(Roles.OrganizationAdministrator); } } else { if (user.Roles.Contains(Roles.OrganizationAdministrator)) { user.Roles.Remove(Roles.OrganizationAdministrator); } } await _userManager.UpdateAsync(user); //await _session.SaveChangesAsync(); return(Guid.Parse(user.Id)); }
public async Task <UserResponse> Update(UpdateUser request) { var requestManager = _mapper.Map <UserAccess>(request); var user = await _userDataAccess.UpdateAsync(requestManager); return(_mapper.Map <UserResponse>(user)); }
private void metroGrid1_CellClick(object sender, DataGridViewCellEventArgs e) { if (e.ColumnIndex == 0) { int Id = (int)metroGrid1.Rows[e.RowIndex].Cells["Id"].Value; UpdateUser f = new UpdateUser(Id); f.Show(); } else if (e.ColumnIndex == 1) { int Id = (int)metroGrid1.Rows[e.RowIndex].Cells["Id"].Value; var result = MetroFramework.MetroMessageBox.Show(this, "آیا مطمئن هستید این آیتم حذف شود؟", "اخطار", MessageBoxButtons.YesNo, MessageBoxIcon.Error); if (result == DialogResult.Yes) { repository.Delete(Id); UserManagement userManagement = (UserManagement)Application.OpenForms["UserManagement"]; userManagement.LoadGrid(); } else { UserManagement userManagement = (UserManagement)Application.OpenForms["UserManagement"]; userManagement.LoadGrid(); } } }
private void BtnUpdateUser_Click(object sender, EventArgs e) { UpdateUser updateUser = new UpdateUser(); this.Hide(); updateUser.Show(); }
public async Task <IActionResult> Edit([FromBody] UpdateUser model, string id) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Users user = await _usersRepository.GetById(id); if (user == null) { return(NotFound()); } if (!HttpContext.User.IsInRole(UserRoles.Administrator) && (HttpContext.User.Identity.Name != user.UserName)) { return(Forbid()); } IdentityRole role = await _rolesRepository.GetById(model.RoleId); if (role == null) { return(BadRequest(ResponseMessage.RoleNotExists)); } user = _mapper.Map <UpdateUser, Users>(model, user); user.DateModified = DateTime.Now; await _usersRepository.Update(user, model.RoleId); return(Ok()); }
private async void btnUpdate_Click(object sender, EventArgs e) { if (lbxUsers.SelectedValue == null) { return; } Permission permissions = 0; for (var i = 0; i < clbPermissions.Items.Count; i++) { permissions |= (Permission)Enum.Parse(typeof(Permission), clbPermissions.Items[i].ToString(), true); } try { var user = await ApiClient.ReadUser((Guid)lbxUsers.SelectedValue); var updateUser = new UpdateUser(user) { FirstName = txtFirstname.Text, LastName = txtLastname.Text, }; user = await ApiClient.UpdateUser(user.Id, updateUser); lbxUsers.SelectedValue = user.Id; } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public Response UpdateUser(UpdateUser updateUser) { using (Entities entities = new Entities()) { var DelUser = entities.Users.Where(x => x.userId == updateUser.userId).FirstOrDefault(); if (DelUser != null) { DelUser.email = updateUser.Email; DelUser.phone = updateUser.Phone.ToString(); DelUser.userName = updateUser.UserName; entities.SaveChanges(); return(new Response() { Status = ResponseTypes.ok }); } else { return(new Response() { Status = ResponseTypes.invalid, ErrorMessageText = "User not exits" }); } } }
public bool UpdateUser(UpdateUser updateUser) { bool result = false; try { var dbUser = FindUserByUserName(updateUser.Username); if (dbUser == null) { return(result); } var user = _mapper.Map(updateUser, dbUser); _context.SaveChanges(); result = true; } catch (System.Exception ex) { _logger.LogError(ex.Message); } return(result); }
public void Update_User_Returns_Valid_User() { // Arrange GetUser(); var user = _sut.Users.GetUser(_userEmail); var originalLastName = user.LastName; var newLastName = $"Last Name {DateTimeOffset.Now.ToUnixTimeMilliseconds()}"; var updateUser = new UpdateUser { FirstName = user.FirstName, LastName = newLastName }; // Act var result = _sut.Users.UpdateUser(_userEmail, updateUser); // Assert result.ShouldNotBeNull(); result.ShouldBe(true); user = _sut.Users.GetUser(_userEmail); user.Email.ShouldBe(_userEmail); user.LastName.ShouldBe(newLastName); // Cleanup _sut.Users.UpdateUser(_userEmail, new UpdateUser { FirstName = user.FirstName, LastName = originalLastName }); }
public void Any(UpdateUser request) { using (var db = DbFactory.OpenDbConnection()) { db.Update <UserAuth>(request.User); } }
public async Task <IActionResult> UpdateDetails(UpdateUser newDetails) { if (!User.Identity.IsAuthenticated) { return(LogIn()); } User user = _userRepo.GetUserList.FirstOrDefault(u => u.UserName == User.Identity.Name); if (user == null) { return(LogIn()); } IdentityResult result = null; List <IdentityError> errors = null; if (!string.IsNullOrEmpty(newDetails.CurrentPassword)) { result = await _userManager.ChangePasswordAsync(user, newDetails.CurrentPassword, newDetails.Password); errors = result.Errors.ToList(); } _userRepo.UpdateUser(user.Id, newDetails); return(UpdateDetails(errors)); }
public IActionResult UpdateProfile(int id, UpdateUser inp, string bio) { List <CurrentUser> ret = HttpContext.Session.GetObjectFromJson <List <CurrentUser> >("curr"); Users showuser = _context.users.Include(u => u.goals).Include(u => u.groups).SingleOrDefault(u => u.id == id); if (ret[0] == null) { return(RedirectToAction("")); } else if (ret[0].id == 0 || ret[0].id != id) { return(RedirectToAction("")); } else { if (ModelState.IsValid) { Users check = _context.users.SingleOrDefault(x => x.id == id); check.first_name = inp.first_name; check.last_name = inp.last_name; check.privacy = inp.privacy; check.bio = bio; _context.SaveChanges(); return(Redirect($"/profile/{id}")); } else { ViewBag.Profile = showuser; ViewBag.CurrentUser = ret[0]; return(View("UpdateInfo")); } } }
public bool UpdateUser(string userId, UpdateUser user) { var request = BuildRequestAuthorization(PATCH_USER, Method.PATCH); request.AddParameter("userId", userId, ParameterType.UrlSegment); request.AddJsonBody(user); var response = WebClient.Execute(request); if (response.ResponseStatus == ResponseStatus.Completed && response.StatusCode == System.Net.HttpStatusCode.NoContent) { return(true); } if (!string.IsNullOrWhiteSpace(response.ErrorMessage)) { throw new Exception(response.ErrorMessage); } if (!string.IsNullOrWhiteSpace(response.StatusDescription) && !string.IsNullOrWhiteSpace(response.Content)) { throw new Exception($"{response.StatusDescription} || {response.Content}"); } return(false); }
public async Task <ActionResult> Update(SettingsPageModel model) { var site = await _contextService.CurrentSiteAsync(); var user = await _contextService.CurrentUserAsync(); if (model.User.Id != user.Id || user.IsSuspended) { _logger.LogWarning("Unauthorized access to update settings.", new { SiteId = site.Id, UserId = model.User?.Id, User = User.Identity.Name }); return(Unauthorized()); } var command = new UpdateUser { Id = user.Id, DisplayName = model.User.DisplayName, SiteId = site.Id, UserId = user.Id }; await _userService.UpdateAsync(command); return(Ok()); }
public string UpdateUser([FromBody] UpdateUser user) { try { if (_context.Users.Any(x => x.UserId == user.UserId)) { var UserDetails = _context.Users.Find(user.UserId); UserDetails.Title = user.Title; UserDetails.FirstName = user.FirstName; UserDetails.LastName = user.LastName; UserDetails.Email = user.Email; UserDetails.Phone = user.Phone; UserDetails.IsAdmin = user.IsAdmin; UserDetails.Address = user.Address; _context.SaveChanges(); return("Success"); } else { return("Error: Group not found!"); } } catch (Exception ex) { return("Error:" + ex.Message); } }
public void Handle(UpdateUser update) { if (update.User.Id == _protoService.Options.MyId) { CreateToastCollection(update.User); } }
public async Task updateuser_command_should_modify_user_with_given_data() { var id = new AggregateId(); var email = "*****@*****.**"; var fullname = "fullname"; var updatedFullname = "updatedfullname"; var password = "******"; var pic = "test.nl/image"; var role = Role.User; var securityStamp = new Guid().ToString(); // Add user var user = new User(id, email, fullname, pic, password, role, securityStamp, 0, DateTime.MinValue, DateTime.UtcNow, new string[] { }); await _mongoDbFixture.InsertAsync(user.AsDocument()); var command = new UpdateUser(id, updatedFullname, pic, null); _commandHandler .Awaiting(c => c.HandleAsync(command)) .Should().NotThrow(); var updatedUser = await _mongoDbFixture.GetAsync(command.UserId); updatedUser.Should().NotBeNull(); updatedUser.Id.Should().Be(command.UserId); updatedUser.Fullname.Should().Be(command.Fullname); updatedUser.Pic.Should().Be(command.Pic); }
public async Task <IActionResult> UpdateUser(string id, UpdateUser model, string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; if (ModelState.IsValid) { if (id == null) { return(View("Error")); } var currentUser = await _userManager.FindByIdAsync(id); if (currentUser == null) { return(View("Error")); } else { currentUser.UserName = model.UserName; currentUser.Email = model.Email; currentUser.PhoneNumber = model.PhoneNumber; currentUser.NameOnCard = model.NameOnCard; currentUser.CreditCard = model.CreditCard; currentUser.CardConfirm = model.CardConfirm; currentUser.Month = model.Month; currentUser.Year = model.Year; currentUser.Line1 = model.Line1; currentUser.Line2 = model.Line2; currentUser.City = model.City; currentUser.State = model.State; currentUser.Zip = model.Zip; currentUser.Country = model.Country; var serviceCollection = new ServiceCollection(); serviceCollection.AddDataProtection(); var services = serviceCollection.BuildServiceProvider(); var instance = ActivatorUtilities.CreateInstance <Encryptor>(services); var content = instance.Encrypt(currentUser.CreditCard); var contentConfirm = instance.Encrypt(currentUser.CardConfirm); currentUser.CreditCard = content; currentUser.CardConfirm = contentConfirm; IdentityResult result = await _userManager.UpdateAsync(currentUser); if (result.Succeeded) { return(RedirectToLocal(returnUrl)); } else { foreach (IdentityError error in result.Errors) { ModelState.AddModelError("", error.Description); } } } } return(View(model)); }
public IHttpActionResult Update(UpdateUser user) { if (user == null) { return(BadRequest()); } // OldPassword needs to be correct var authenticatedUser = _userRepository.Authenticate(user.UserName, user.PasswordOld); if (authenticatedUser == null) { return(BadRequest("Old password not okay")); } if (user.PasswordOld == user.Password) { return(BadRequest("New password must be different from old one")); } if (!CheckPasswordAndVerification(user, out var error)) { return(error); } var result = _userRepository.Update(authenticatedUser.Id, user.Password); return(result ? (IHttpActionResult)Ok() : BadRequest()); }
/// <summary> /// Posts the specified request. /// </summary> /// <param name="request">The request.</param> public void Post(UpdateUser request) { // We need to parse this manually because we told service stack not to with IRequiresRequestStream // https://code.google.com/p/servicestack/source/browse/trunk/Common/ServiceStack.Text/ServiceStack.Text/Controller/PathInfo.cs var id = GetPathValue(1); AssertCanUpdateUser(_authContext, _userManager, id, false); var dtoUser = request; var user = _userManager.GetUserById(id); if (string.Equals(user.Name, dtoUser.Name, StringComparison.Ordinal)) { _userManager.UpdateUser(user); } else { var task = _userManager.RenameUser(user, dtoUser.Name); Task.WaitAll(task); } _userManager.UpdateConfiguration(dtoUser.Id, dtoUser.Configuration); }
public ActionResult Update(string userSlug, UpdateUser command) { command.User.Id = EventSite.Domain.Model.User.IdFrom(userSlug); return Execute(command) .OnSuccess(x => View("Update", command)) .OnFailure(x => View("Update", command)); }
public Response Patch(UpdateUser request) { request.Username = request.Username.Trim(); request.Email = request.Email.Trim(); Db.Update(request.ConvertTo<User>()); Request.RemoveFromCache(Cache, request.Id.ToString()); return new Response(true); }
public void Put(UpdateUser request) { _userRepo.Update(new User { FullName = request.FullName, UserName = request.UserName, Id = request.Id, RoleId = request.RoleId }); }
public ActionResult Update(string userSlug) { var user = LoadUserFromSlug(userSlug); if (user == null) { return NotFound(); } var userData = new UpdateUser(); userData.User = user; userData.InAdminRole = user.InRole(Roles.Admin); userData.InSponsorManagerRole = user.InRole(Roles.ManageSponsors); return View(userData); }
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException(AuthorizationBuilder.UserType userType) { // Arrange IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType); UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>(); var handler = new UpdateUserHandler(authorization, userManager); var request = new UpdateUser(Guid.NewGuid().ToString(), "TestFirstName", "TestLastName"); // Act Func<Task> action = async () => await handler.HandleAsync(request); // Assert await Assert.ThrowsAsync<SecurityException>(action); }
public async Task HandleAsync_WithUnknownUserId_ThrowsArgumentException() { // Arrange IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights(); UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>(); A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns((ApplicationUser)null); var handler = new UpdateUserHandler(authorization, userManager); var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "TestFirstName", "TestLastName"); // Act Func<Task> action = async () => await handler.HandleAsync(request); // Assert await Assert.ThrowsAsync<ArgumentException>(action); }
public ActionResult UpdateUserType(UpdateUser input) { var result = new {Succss = true, Message = "Updated"}; return Json(result); }
public User Update(UpdateUser request) { var httpRequest = RequestContext.Get<IHttpRequest>(); var userSession = httpRequest.GetSession(); if(!( userSession.HasRole(RoleNames.Admin) || userSession.HasPermission("User.update") )) throw HttpError.Unauthorized("Update no allowed"); var authRepo = httpRequest.TryResolve<IUserAuthRepository>(); if(authRepo==null) throw HttpError.NotFound("AuthRepository NO found"); var user= authRepo.GetUserAuth(request.Id.ToString()); if (!(request.Id== int.Parse(userSession.UserAuthId) || userSession.HasRole(RoleNames.Admin)) ) throw HttpError.Unauthorized("Update no allowed (no admin)"); if(user == default(UserAuth)) throw HttpError.NotFound( string.Format("User Id:'{0}' NO found",request.Id)); var newUser= new UserAuth { Id= request.Id, FirstName= request.FirstName, LastName= request.LastName, Email= request.Email, UserName= request.UserName, DisplayName= request.FirstName+" "+request.LastName, ModifiedDate= DateTime.Now, }; newUser.Set<UserMeta>( new UserMeta{ Info= request.Info, IsActive=request.IsActive, ExpiresAt= request.ExpiresAt }); if(request.Password.IsNullOrEmpty()) { AuthRepoProxy.Execute(db=>{ db.UpdateOnly( newUser, ev=>ev.Where(q=>q.Id==request.Id). Update(f=> new { f.UserName, f.FirstName, f.LastName, f.Email, f.Meta, f.DisplayName, f.ModifiedDate })); }); } else { user = authRepo.UpdateUserAuth(user, newUser,request.Password); } User u = new User(); u.PopulateWith(newUser); return u; }
public async Task HandleAsync_HappyPath_UpdatedUserInformation() { // Arrange IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights(); ApplicationUser user = new ApplicationUser(); UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>(); A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns(user); A.CallTo(() => userManager.UpdateAsync(user)).Returns(IdentityResult.Success); var handler = new UpdateUserHandler(authorization, userManager); var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "Test", "Test"); // Act var result = await handler.HandleAsync(request); // Assert Assert.Equal(user.FirstName, "Test"); Assert.Equal(user.Surname, "Test"); A.CallTo(() => userManager.UpdateAsync(user)).MustHaveHappened(); }