public void Update_IdIsNotEqualUser_ReturnBadRequest(int userId)
{
User user = users.First(x => x.id == userId);
var result = _controller.Update(2, user);
Assert.IsType <BadRequestResult>(result);
}
private void LstUsers_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (lstUsers.SelectedItems.Count > 0)
{
ListViewItem selected = lstUsers.SelectedItems[0];
User selectedUser = selected.Tag as User;
if (!selectedUser.IsActive)
//Bu if'i teklemeye calış "Aktiflik durumunu değiştirmek istiyormusunuz?"
{
DialogResult result = MessageBox.Show("Bu kullanıcıyı onaylıyormusunuz?", "Onay", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
selectedUser.IsActive = true;
_userController.Update(selectedUser);
FillUser();
}
}
else
{
DialogResult result = MessageBox.Show("Bu kullanıcıyı kara listeye almak istiyor musunuz?", "Onay", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
selectedUser.IsActive = false;
_userController.Update(selectedUser);
FillUser();
}
}
}
}
public void Should_Update_User()
{
// Arrange
var userModel = new UserViewModel
{
UserId = Guid.NewGuid(),
Title = "Mr.",
FirstName = "John",
LastName = "Doe",
DateOfBirth = new DateTime(1980, 3, 6),
PhoneNumber = "(123) 456 7890"
};
userServiceMock
.Setup(m => m.Get(It.IsAny <Guid>()))
.Returns(new User());
// Act
var response = controller.Update(userModel);
var okResult = response as OkResult;
// Assert
unitOfWorkMock
.Verify(m => m.Commit(), Times.Once);
Assert.IsNotNull(okResult);
Assert.AreEqual(okResult.StatusCode, 200);
}
private void lstUsers_DoubleClick(object sender, EventArgs e)
{
if (lstUsers.SelectedItems.Count > 0)
{
ListViewItem selected = lstUsers.SelectedItems[0];
User selectedUser = selected.Tag as User;
if (selectedUser.IsActive == false)
{
DialogResult result = MessageBox.Show("Kullanıcıyı onaylamak istiyor musunuz", "Onay", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
selectedUser.IsActive = true;
_userController.Update(selectedUser);
FillUser();
}
}
else
{
DialogResult result = MessageBox.Show("Kullanıcıyı karalisteye almak istiyor musunuz?", "Kara liste", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning);
if (result == DialogResult.Yes)
{
selectedUser.IsActive = false;
_userController.Update(selectedUser);
FillUser();
}
}
}
}
public void ReturnOkWhenUserFound()
{
//Given
_svc.Setup(s => s.Update(It.IsAny <User>(), It.IsAny <string>()))
.Returns(UserFixtures.ValidUser());
//When
var rv = _controller.Update(UserFixtures.DtoUser());
//Then
Assert.IsType <OkObjectResult>(rv);
}
public void Update_ValidUpdateUser_UpdateCalled()
{
var fakeUserViewModel = new UserViewModel()
{
Name = "test", SelectedRolesName = new List <string>()
};
var fakeUserDTO = _mapper.Map <UserDTO>(fakeUserViewModel);
_userService.Setup(service => service.IsUniqueName(It.IsAny <UserDTO>())).Returns(true);
_userService.Setup(service => service.Update(fakeUserDTO));
_sut.Update(fakeUserViewModel);
_userService.Verify(s => s.Update(It.IsAny <UserDTO>()), Times.Once);
}
private void UpdateBook()
{
GetAllBook();
string bookId = "";
do
{
Console.WriteLine("Input Book ID : ");
bookId = Console.ReadLine();
}while (userController.CheckBookID(bookId));
string bookTitle = "";
string bookAuthor = "";
int price = 0;
Console.WriteLine("Input book title: ");
bookTitle = Console.ReadLine();
Console.WriteLine("Input book author: ");
bookAuthor = Console.ReadLine();
userController.Update(bookId, bookTitle, bookAuthor);
Console.WriteLine("Update success");
}
public void Put_User_Ok()
{
try
{
SqliteConnection.Open();
IActionResult saveResult = SaveUser();
//Update user
using (IRepository <Models.User> repository = GetRepository <Models.User>())
{
UserController controller = new UserController(repository);
//Act
DTO.User user = ((OkObjectResult)saveResult).Value as DTO.User;
//Set password because save API not returns it
user.Password = "******";
user.Email = "*****@*****.**";
IActionResult result = controller.Update(user);
//Assert
Assert.True(saveResult is OkObjectResult);
Assert.True(result is OkResult);
}
}
finally
{
SqliteConnection.Close();
}
}
public void Update_UserDoesNotExist()
{
var controller = new UserController();
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
LiteDatabase db = database;
var col = db.GetCollection <User>();
if (!col.Exists(Query.EQ("Id", 9998)))
{
col.Delete(9998);
}
if (!col.Exists(Query.EQ("Id", 9999)))
{
col.Delete(9999);
}
col.Insert(new User {
username = "******", password = "******", status = "admin", id = 9999
});
var response = controller.Update(JObject.Parse("{\"id\": 9999, \"update\": 9998, \"status\": \"admin\" }"));
// Assert
Assert.AreNotEqual(null, response);
var tmp = response as BadRequestErrorMessageResult;
Assert.AreEqual("There is no user with this id in the database!", tmp.Message);
}
public void UpdateTests()
{
var getUser = _userController.Update(userDTO);
Assert.NotNull(getUser);
Assert.IsInstanceOf <long>(getUser);
}
public void Update()
{
// Arrange
UserController controller = new UserController();
var item = new User
{
UserName = "******",
RoleId = 1,
Password = "******",
CreatedDate = DateTime.Now,
FullName = "Hoang Thi Hang",
Phone = "0123456",
Email = "*****@*****.**",
Address = "Bac Giang",
Department = "CMC Global",
Position = "GDP07",
Avatar = "AvtHthang",
Note = "She is a Imployee",
Status = true
};
// Act
string result = controller.Update(26, JsonConvert.SerializeObject(item));
// Assert
Assert.AreEqual("1", result);
}
public async Task Test6_Update()
{
//Arrange
var updatedName = "Sandip3";
var fakeCustomerUser = UserFakes.GetFakeCustomerUser();
var userDataForUpdate = new UserDataForUpdate
{
Id = fakeCustomerUser.Id,
Address = fakeCustomerUser.Address,
ContactNumber = fakeCustomerUser.ContactNumber,
Country = fakeCustomerUser.Country,
Email = fakeCustomerUser.Email,
PAN = fakeCustomerUser.PAN,
Password = fakeCustomerUser.LoginData.Password,
State = fakeCustomerUser.State,
Name = updatedName
};
//Act
await _customerUserController.Update(userDataForUpdate);
var userResult = await _customerUserController.Get();
//Assert
((userResult as OkObjectResult).Value as User).Name.Should().Be(updatedName);
}
public void Update_ShouldUpdateCorrectUser()
{
//arrange
var testUsers = GetTestUsers();
var userDtoToBeUpdated = new UserDto()
{
Id = 4,
FirstName = "FirstName_Mocked",
LastName = "LastName_Mocked",
EmployeeId = "Mocker_Employee"
};
var oldUser = testUsers.First(u => u.Id == userDtoToBeUpdated.Id);
var mockUserRepository = new Mock <IUserRepository>().Object;
Mock.Get <IUserRepository>(mockUserRepository).Setup(r => r.Get(userDtoToBeUpdated.Id)).Returns(oldUser);
var userFacade = new UserFacade(mockUserRepository);
var userController = new UserController(userFacade);
//act
var result = userController.Update(userDtoToBeUpdated) as OkNegotiatedContentResult <UserDto>;
//assert
Assert.AreEqual(userDtoToBeUpdated.FirstName, result.Content.FirstName);
Assert.AreEqual(userDtoToBeUpdated.LastName, result.Content.LastName);
}
public void UpdateUser()
{
// Arrange
Mock <IUserService> userService = new Mock <IUserService>();
User user = new User()
{
Id = 1,
FirstName = "admin",
LastName = "admin",
Username = "******",
};
userService.Setup(m => m.Update(user, "admin"));
;
Mock <ILogger <UserController> > logger = new Mock <ILogger <UserController> >();
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new AutoMapperProfile());
});
var mapper = mockMapper.CreateMapper();
var updateModel = new UpdateModel()
{
FirstName = "admin2", LastName = "admin2", Username = "******", Password = "******"
};
var controller = new UserController(logger.Object, userService.Object, mapper);
// Act
var result = controller.Update(1, updateModel);
// Assert
Assert.True(result is OkResult);
Assert.AreEqual(StatusCodes.Status200OK, ((OkResult)result).StatusCode);
}
public void Update_UserDoesExist()
{
var controller = new UserController(database);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
LiteDatabase db = database;
var col = db.GetCollection <User>();
if (!col.Exists(Query.EQ("Id", 9998)))
{
col.Delete(9998);
}
col.Insert(new User {
username = "******", password = "******", status = "user", id = 9998
});
if (!col.Exists(Query.EQ("Id", 9999)))
{
col.Delete(9999);
}
col.Insert(new User {
username = "******", password = "******", status = "admin", id = 9999
});
var response = controller.Update(JObject.Parse("{\"id\": 9999, \"update\": 9998, \"status\": \"admin\" }"));
// Assert
Assert.AreNotEqual(null, response);
var tmp = response as OkNegotiatedContentResult <string>;
Assert.AreEqual("User status has been updated!", tmp.Content);
}
public void Update_ShouldAddNewUser()
{
//arrange
var testUsers = GetTestUsers();
var newUserDto = new UserDto()
{
FirstName = "FirstName_Mocked",
LastName = "LastName_Mocked",
EmployeeId = "Mocker_Employee"
};
var newUser = Mapper.Map <User>(newUserDto);
var mockUserRepository = new Mock <IUserRepository>().Object;
Mock.Get <IUserRepository>(mockUserRepository).Setup(r => r.Add(newUser)).Returns(newUser);
var userFacade = new UserFacade(mockUserRepository);
var userController = new UserController(userFacade);
//act
var result = userController.Update(newUserDto) as OkNegotiatedContentResult <UserDto>;
//assert
Assert.AreEqual(newUserDto.FirstName, result.Content.FirstName);
Assert.AreEqual(newUserDto.LastName, result.Content.LastName);
}
static void Main(string[] args)
{
var context = new AppDbContext();
{
}
var userCtrl = new UserController();
userCtrl.GetAll().ToList().ForEach(u => Console.WriteLine(u));
Console.WriteLine(userCtrl.GetByPk(1));
var user = new User();
user.Id = 1;
user.Username = "******";
user.Password = "******";
Console.WriteLine(user);
user.Firstname = "Vaughn";
user.Lastname = "Cunningham";
user.Phone = "555-555-5555";
user.Email = "*****@*****.**";
user.IsAdmin = true;
user.IsReviewer = false;
Console.WriteLine("Update successful!");
userCtrl.Update(user.Id, user);
user = userCtrl.Insert(user);
//userCtrl.GetAll().ToList().ForEach(u => Console.WriteLine(u));
//userCtrl.Delete(user);
//Console.WriteLine("Delete Successful!");
}
public void ChangeEmailAndNameTest()
{
string email = "*****@*****.**";
string name = "Adam Swank";
var user = userController.Create(name, email);
var fetchedUser = userController.Get(user.Id);
Assert.NotNull(fetchedUser);
var updates = new Dictionary <string, string>();
updates.Add("email", "*****@*****.**");
updates.Add("name", "me");
userController.Update(user, updates);
fetchedUser = userController.Get(user.Id);
Assert.NotNull(fetchedUser);
Assert.Equal(user.Id, fetchedUser.Id);
Assert.Equal("*****@*****.**", fetchedUser.Email);
Assert.Equal("me", fetchedUser.Name);
}
public async Task Update_WithPasswordChange_ReturnsUpdatedUser()
{
// Arrange
var mockUserManager = Setup.GetUserManagerMock();
var mockRoleManager = Setup.GetRoleManagerMock();
var controller = new UserController(mockUserManager.Object, mockRoleManager.Object);
mockUserManager.Setup(userManager => userManager.FindByIdAsync(It.IsAny <string>())).ReturnsAsync((string userId) => new ApplicationUser()
{
Id = Convert.ToInt32(userId)
});
mockUserManager.Setup(userManager => userManager.UpdateAsync(It.IsAny <ApplicationUser>())).ReturnsAsync(IdentityResult.Success);
mockUserManager.Setup(userManager => userManager.RemovePasswordAsync(It.IsAny <ApplicationUser>())).ReturnsAsync(IdentityResult.Success).Verifiable();
mockUserManager.Setup(userManager => userManager.AddPasswordAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success).Verifiable();
// Act
var result = await controller.Update(1, new UserUpdateViewModel()
{
Password = "******"
});
// Assert
mockUserManager.Verify();
var okObjectResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <UserViewModel>(okObjectResult.Value);
}
public async Task Update_WithUser_ReturnUpdatedUser()
{
// Arrange
var userStamp = "NewUserStamp";
var mockUserManager = Setup.GetUserManagerMock();
var mockRoleManager = Setup.GetRoleManagerMock();
var controller = new UserController(mockUserManager.Object, mockRoleManager.Object);
mockUserManager.Setup(userManager => userManager.FindByIdAsync(It.IsAny <string>())).ReturnsAsync((string userId) => new ApplicationUser()
{
Id = Convert.ToInt32(userId)
});
mockUserManager.Setup(userManager => userManager.UpdateAsync(It.Is <ApplicationUser>(appUser => appUser.Id.Equals(1))))
.ReturnsAsync((ApplicationUser appUser) =>
{
appUser.ConcurrencyStamp = userStamp;
return(IdentityResult.Success);
});
// Act
var result = await controller.Update(1, new UserUpdateViewModel()
{
ConcurrencyStamp = "OldUserStamp"
});
// Assert
mockUserManager.Verify(userManager => userManager.RemoveFromRolesAsync(It.IsAny <ApplicationUser>(), It.IsAny <IEnumerable <string> >()), Times.Never());
mockUserManager.Verify(userManager => userManager.AddToRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()), Times.Never());
mockUserManager.Verify(userManager => userManager.RemovePasswordAsync(It.IsAny <ApplicationUser>()), Times.Never());
mockUserManager.Verify(userManager => userManager.AddPasswordAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()), Times.Never());
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var user = Assert.IsAssignableFrom <UserViewModel>(okObjectResult.Value);
Assert.Equal(userStamp, user.ConcurrencyStamp);
}
protected void Update_Click(object sender, EventArgs e)
{
tbUserInfo obj = new tbUserInfo();
obj.Name = txtName.Text;
obj.Username = txtUserName.Text;
obj.Address = txtAddress.Text;
obj.Email = txtEmail.Text;
obj.Phone = txtPhone.Text;
obj.Active = chkActive.Checked;
obj.RoleId = int.Parse
(ddlRole.SelectedValue.ToString());
obj.Password = txtPass.Text;
obj.Id = int.Parse(Id);
if (insert)
{
UserController.Insert(obj);
}
else
{
obj.Id = int.Parse(Id);
UserController.Update(obj);
}
pnView.Visible = true;
pnUpdate.Visible = false;
_LoadUser();
}
public void Update_InsufficientPermission()
{
var controller = new UserController(database);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
LiteDatabase db = database;
var col = db.GetCollection <User>();
if (!col.Exists(Query.EQ("Id", 9998)))
{
col.Delete(9998);
}
col.Insert(new User {
username = "******", password = "******", status = "user", id = 9998
});
if (!col.Exists(Query.EQ("Id", 9999)))
{
col.Delete(9999);
}
col.Insert(new User {
username = "******", password = "******", status = "user", id = 9999
});
var response = controller.Update(JObject.Parse("{\"id\": 9999, \"update\": 9998, \"status\": \"admin\" }"));
// Assert
Assert.AreNotEqual(null, response);
var tmp = response as BadRequestErrorMessageResult;
Assert.AreEqual("You don't have sufficient rights to change status of the user!", tmp.Message);
}
public async Task UpdateUserWithParameterIdIs3_ShouldReturnHttpStatusCode200AndUserModel()
{
HttpJsonApiResult <UserModel> data = await _userController.Update(3, new UserUpdateRequest()
{
Name = "Tukar Nama",
Email = "*****@*****.**",
Jabatan = "Tukar jabatan",
Role = EUserRole.Admin
}) as HttpJsonApiResult <UserModel>;
Assert.AreEqual(data.StatusCode, HttpStatusCode.OK);
Assert.AreEqual(data.DataValue.Name, "Tukar Nama");
Assert.AreEqual(data.DataValue.Email, "*****@*****.**");
Assert.AreEqual(data.DataValue.Jabatan, "Tukar jabatan");
Assert.AreEqual(data.DataValue.Role, "Admin");
Assert.AreEqual(data.DataValue.UserRole, EUserRole.Admin);
}
private void MethodPutUpdatesUser()
{
//Setup repo Mock
_userServiceMock.Setup(service => service.Update(1, _userDto1));
ResponseObject response = new ResponseObject {
Data = _userDto1
};
//Check if controller return Ok-response
var actionResult = _controller.Update(1, response);
Assert.IsType <OkObjectResult>(actionResult);
Assert.Equal(_userDto1, response.Data);
//Check if Add-method is called in controller
_userServiceMock.Verify(service => service.Update(1, _userDto1), Times.Once);
}
public void DeveRetornarActionResultNotFoundAoAtualizarUsuarioInvalido()
{
var sut = new UserController(_userServiceMock.Object);
var result = sut.Update(_userHelper.UpdateUserInputInvalid) as NotFoundObjectResult;
Assert.IsInstanceOf <NotFoundObjectResult>(result);
}
private void btnSave_Click(object sender, EventArgs e)
{
User.FirstName = txtName.Text;
User.LastName = txtSurname.Text;
User.BirthDate = dtpBirthDate.Value;
User.RoleID = roleID;
_userController.Update(User);
}
public void Update_UserOfId()
{
OkObjectResult result1 = (OkObjectResult)Controller.Get(21);
User resultItem1 = (User)result1.Value;
OkObjectResult result = (OkObjectResult)Controller.Update(resultItem1.Id, resultItem1);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
}
internal static IHttpActionResult Update()
{
var userResult = GetAll() as OkNegotiatedContentResult <IEnumerable <User> >;
var users = userResult.Content.ToList();
var response = baseController.Update(users);
return(response);
}
public void DeveRetornarActionResultBadRequestAoAtualizarUsuarioInvalido()
{
_userServiceMock.Setup(serv => serv.Update(_userHelper.UpdateUserInputInvalid)).Returns(_userHelper.UserInvalid);
var sut = new UserController(_userServiceMock.Object);
var result = sut.Update(_userHelper.UpdateUserInputInvalid) as BadRequestObjectResult;
Assert.IsInstanceOf <BadRequestObjectResult>(result);
}
public async Task Update500sOnUnauthorized()
{
UserRepoMock repo = new UserRepoMock();
UserController controller = new UserController {
UserRepo = repo
};
ActionResult result = await controller.Update(new UserController.NewUser());
Assert.AreEqual(401, (result as StatusCodeResult).StatusCode);
}
