public ShowViewsController(Helpers helpers, MovieGameContext context, SessionUser sessionUser, ManageUsersController manageUsers)
{
_helpers = helpers;
_context = context;
_sessionUser = sessionUser;
_manageUsers = manageUsers;
}
public void ListUsers()
{
//Arrange
var users = new List <ApplicationUser>
{
new ApplicationUser {
FirstName = "John", LastName = "Dianala"
},
new ApplicationUser {
FirstName = "Joleo", LastName = "Dianala"
}
};
var mocRepo = new Mock <IRepository>();
mocRepo.Setup(Mock => Mock.Query <ApplicationUser>()).Returns(users.AsQueryable());
ManageUsersController myController = new ManageUsersController();
//Act
var results = myController.Index() as ViewResult;
var model = results.Model as IList <ApplicationUser>;
// Assert
Assert.AreEqual("John", model.First().UserName);
}
public void TestListUsers()
{
//Arrange
var users = new List <ApplicationUser> {
new ApplicationUser {
FirstName = "Bob", LastName = "Bobson"
},
new ApplicationUser {
FirstName = "Andrew", LastName = "Anderson"
},
new ApplicationUser {
FirstName = "Carl", LastName = "Caaaaarrrllllllll"
}
};
var mockRepo = new Mock <IRepository>();
mockRepo.Setup(mock => mock.Query <ApplicationUser>()).Returns(users.AsQueryable());
var manageUsersController = new ManageUsersController(mockRepo.Object);
//Act
var results = manageUsersController.Index() as ViewResult;
var model = results.Model as IList <ApplicationUser>;
//Assert
Assert.AreEqual("Andrew", model.First().FirstName);
}
public void UpdateUserInfo_ShouldReturnOkResult_WhenCreateAsyncSucceded()
{
mapper.Execute();
string testId = "testId";
var users = new Mock <IUsersService>();
users.Setup(x => x.IsCompanyAndBulstatCompatibiltyValid(It.IsAny <User>())).Returns(() => true);
users.Setup(x => x.Update(It.IsAny <User>())).Returns(() => new User()
{
Id = testId
});
UserUpdateModel request = new UserUpdateModel()
{
Id = testId
};
var controller = new ManageUsersController(users.Object, null, null);
var result = controller.UpdateUserInfo(request);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <UserResponseModel>));
var responseContent = ((OkNegotiatedContentResult <UserResponseModel>)result).Content;
Assert.AreEqual(responseContent.Id, testId);
users.VerifyAll();
}
public void TestIndexView()
{
ManageUsersController manageControllerTest = new ManageUsersController();
var result = manageControllerTest.Index() as ViewResult;
Assert.AreEqual("", result.ViewName);
}
public ManageUsersControllerTest()
{
_userManagerMock = new Mock <FakeUserManager>();
_manageUsersController = new ManageUsersController(_userManagerMock.Object);
_manageUsersController.ControllerContext = new ControllerContext();
_manageUsersController.ControllerContext.HttpContext = new DefaultHttpContext();
}
public async Task SendEmailConfirmation_ShouldReturnInternalServerErrorAndLogError_WhenUsersServiceIsNull()
{
var controller = new ManageUsersController(null, null, null, mockedLogger.Object);
var result = await controller.SendEmailConfirmation(null);
Assert.IsInstanceOfType(result, typeof(InternalServerErrorResult));
mockedLogger.Verify(x => x.LogError(It.IsAny <Exception>(), "", controllerName, "SendEmailConfirmation"));
}
public void UpdateUserInfo_ShouldReturnInternalServerErrorAndLogError_WhenUsersServiceIsNull()
{
var controller = new ManageUsersController(null, null, null, mockedLogger.Object);
var result = controller.UpdateUserInfo(null);
Assert.IsInstanceOfType(result, typeof(InternalServerErrorResult));
mockedLogger.Verify(x => x.LogError(It.IsAny <Exception>(), "", controllerName, "UpdateUserInfo"));
}
public void Get_ShouldReturnUsersInCorrectSequence()
{
mapper.Execute();
string testUserId1 = "testId1";
string testUserId2 = "testId2";
string testUserId3 = "testId3";
string testUserId4 = "testId4";
string testUserId5 = "testId5";
var users = new List <User>()
{
new User()
{
Id = testUserId1, CreatedOn = DateTime.Now
},
new User()
{
Id = testUserId2, CreatedOn = DateTime.MinValue
},
new User()
{
Id = testUserId3, CreatedOn = DateTime.MinValue
},
new User()
{
Id = testUserId4, CreatedOn = DateTime.MinValue
},
new User()
{
Id = testUserId5, CreatedOn = DateTime.MinValue
},
}.AsQueryable();
var usersMock = new Mock <IUsersService>();
usersMock.Setup(x => x.GetAll()).Returns(users);
var controller = new ManageUsersController(usersMock.Object, null, null);
var result = controller.Get();
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <List <UserResponseModel> >));
var responseContent = ((OkNegotiatedContentResult <List <UserResponseModel> >)result).Content;
Assert.AreEqual(responseContent[0].Id, testUserId1);
Assert.AreEqual(responseContent[1].Id, testUserId2);
Assert.AreEqual(responseContent[2].Id, testUserId3);
Assert.AreEqual(responseContent[3].Id, testUserId4);
Assert.AreEqual(responseContent[4].Id, testUserId5);
usersMock.VerifyAll();
}
public async Task EnableAuthenticator_ReturnsViewResult_WhenSucceeded()
{
SetGetUserAsyncMethod();
_userManagerMock
.Setup(ManageUsersController => ManageUsersController.GetAuthenticatorKeyAsync(It.IsAny <ApplicationUser>()))
.ReturnsAsync("test_string");
var result = await _manageController.EnableAuthenticator();
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <EnableAuthenticatorViewModel>(viewResult.Model);
}
public async Task SendEmailConfirmation_ShouldReturnOkResult()
{
mapper.Execute();
string testEmail = "testEmail";
string testId = "testId";
string testCode = "testCode";
string testRoute = "/testRoute";
string fullCallbackUrl = $"{GlobalConstants.AppDomainPath}/confirmemail?userid={testId}&code={testCode}";
var usersMock = new Mock <IUsersService>();
usersMock.Setup(x => x.GetByEmail(testEmail)).Returns(() => new User()
{
Id = testId, Email = testEmail
});
var userStore = new Mock <IUserStore <User> >();
var userManagerMock = new Mock <ApplicationUserManager>(userStore.Object);
userManagerMock.Setup(x => x.GenerateEmailConfirmationTokenAsync(testId)).ReturnsAsync(testCode);
var emailsMock = new Mock <IEmailsService>();
emailsMock.Setup(x => x.SendEmail(testEmail, GlobalConstants.ConfirmEmailSubject,
string.Format(GlobalConstants.ConfirmEmailBody, fullCallbackUrl), GlobalConstants.SMTPServer,
GlobalConstants.EmailPrimary, GlobalConstants.EmailPrimaryPassword));
var urlMock = new Mock <UrlHelper>();
urlMock.Setup(m => m.Route(It.IsAny <string>(), It.IsAny <object>())).Returns(testRoute);
AccountEmailRequestModel request = new AccountEmailRequestModel()
{
Email = testEmail
};
var controller = new ManageUsersController(usersMock.Object, emailsMock.Object, userManagerMock.Object, null)
{
Url = urlMock.Object
};
var result = await controller.SendEmailConfirmation(request);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <string>));
var responseContent = ((OkNegotiatedContentResult <string>)result).Content;
Assert.AreEqual(fullCallbackUrl, responseContent);
usersMock.VerifyAll();
userManagerMock.VerifyAll();
emailsMock.VerifyAll();
}
public async Task RedirectToAction_UserDetails()
{
var userService = new Mock <IUsersService>();
var mockUserManager = GetUserManagerMock();
var mockRoleManager = GetRoleManagerMock();
var user = GetUser();
userService.Setup(u => u.DeleteUserAsync(It.IsAny <string>()))
.ReturnsAsync(user);
var controller = new ManageUsersController(mockUserManager.Object, mockRoleManager.Object, userService.Object);
var result = await controller.DeleteUser(user.Id) as RedirectToActionResult;
Assert.AreEqual("UserDetails", result.ActionName);
}
public void UpdateUserInfo_ShouldReturnBadRequest_WhenIsValidUserIsFalse()
{
mapper.Execute();
var users = new Mock <IUsersService>();
users.Setup(x => x.IsCompanyAndBulstatCompatibiltyValid(It.IsAny <User>())).Returns(() => false);
var controller = new ManageUsersController(users.Object, null, null);
var result = controller.UpdateUserInfo(null);
Assert.IsInstanceOfType(result, typeof(BadRequestErrorMessageResult));
string responseMessage = ((BadRequestErrorMessageResult)result).Message;
Assert.IsTrue(responseMessage.Contains(GlobalConstants.InvalidCompanyBulstatCombination));
users.VerifyAll();
}
public void TestHandleAdminAction()
{
var USER = _helper.testUsers[0];
ManageUsersController manageControllerTest = new ManageUsersController();
AdminActionRequestModel model = new AdminActionRequestModel()
{
Username = USER.Username,
Action = "MakeAdmin"
};
//Test make admin
var result = manageControllerTest.HandleAdminAction(model) as JsonResult;
Assert.AreEqual(0, ((AdminActionResponseModel)result.Data).Errors.Count);
Assert.AreEqual("Action Succesfully Completed.", ((AdminActionResponseModel)result.Data).Message);
UserDTO user = UserService.GetUser(USER.Username);
Assert.AreEqual(RoleLevel.Admin, user.Role);
//Test blocking user
model.Action = "Block";
result = manageControllerTest.HandleAdminAction(model) as JsonResult;
Assert.AreEqual(0, ((AdminActionResponseModel)result.Data).Errors.Count);
Assert.AreEqual("Action Succesfully Completed.", ((AdminActionResponseModel)result.Data).Message);
user = UserService.GetUser(USER.Username);
Assert.AreEqual(RoleLevel.Blocked, user.Role);
//Test unblocking user
model.Action = "Unblock";
result = manageControllerTest.HandleAdminAction(model) as JsonResult;
Assert.AreEqual(0, ((AdminActionResponseModel)result.Data).Errors.Count);
Assert.AreEqual("Action Succesfully Completed.", ((AdminActionResponseModel)result.Data).Message);
user = UserService.GetUser(USER.Username);
Assert.AreEqual(RoleLevel.User, user.Role);
//Test deleting user
model.Action = "Delete";
result = manageControllerTest.HandleAdminAction(model) as JsonResult;
Assert.AreEqual(0, ((AdminActionResponseModel)result.Data).Errors.Count);
Assert.AreEqual("Action Succesfully Completed.", ((AdminActionResponseModel)result.Data).Message);
user = UserService.GetUser(USER.Username);
Assert.AreEqual(null, user);
}
public async Task PostEnableAuthenticator_ReturnsViewResult_WithErrors_WhenCanNotVerifyTwoFactorToken()
{
SetGetUserAsyncMethod();
_userManagerMock
.Setup(ManageUsersController => ManageUsersController.GetAuthenticatorKeyAsync(It.IsAny <ApplicationUser>()))
.ReturnsAsync("test_string");
_userManagerMock
.Setup(ManageUsersController =>
ManageUsersController.VerifyTwoFactorTokenAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(false);
var result = await _manageController.EnableAuthenticator(new EnableAuthenticatorViewModel { Code = "test code" });
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <EnableAuthenticatorViewModel>(viewResult.Model);
Assert.Single(_manageController.ModelState);
}
public async Task GenerateRecoveryCodes_ReturnsViewResult_WhenSucceeded()
{
_userManagerMock
.Setup(manager => manager.GetUserAsync(It.IsAny <ClaimsPrincipal>()))
.ReturnsAsync(new ApplicationUser {
TwoFactorEnabled = true
});
_userManagerMock
.Setup(ManageUsersController =>
ManageUsersController.GenerateNewTwoFactorRecoveryCodesAsync(It.IsAny <ApplicationUser>(), It.IsAny <int>()))
.ReturnsAsync(new List <string>());
var result = await _manageController.GenerateRecoveryCodes();
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <ShowRecoveryCodesViewModel>(viewResult.Model);
Assert.Equal("ShowRecoveryCodes", viewResult.ViewName);
}
public async Task Return_UserDetailsView()
{
var userService = new Mock <IUsersService>();
var mockUserManager = GetUserManagerMock();
var mockRoleManager = GetRoleManagerMock();
var user = GetUser();
userService.Setup(u => u.GetUserWithSensorsAsync(It.IsAny <string>()))
.ReturnsAsync(user);
mockUserManager.Setup(u => u.GetRolesAsync(It.IsAny <User>()))
.ReturnsAsync(new List <string>()
{
"User"
});
var controller = new ManageUsersController(mockUserManager.Object, mockRoleManager.Object, userService.Object);
var result = await controller.UserDetails(user.Id) as ViewResult;
Assert.AreEqual("UserDetails", result.ViewName);
}
public async Task ReturnUser_AsUserWithRolesViewModel()
{
var userService = new Mock <IUsersService>();
var mockUserManager = GetUserManagerMock();
var mockRoleManager = GetRoleManagerMock();
var user = GetUser();
mockUserManager.Setup(u => u.FindByIdAsync(It.IsAny <string>()))
.ReturnsAsync(user);
mockUserManager.Setup(u => u.GetRolesAsync(It.IsAny <User>()))
.ReturnsAsync(new List <string>()
{
"User"
});
var controller = new ManageUsersController(mockUserManager.Object, mockRoleManager.Object, userService.Object);
var result = await controller.Roles(user.Id) as ViewResult;
var viewModel = (UserWithRolesModel)result.ViewData.Model;
Assert.AreEqual(user.Id, viewModel.Id);
}
public async Task PostEnableAuthenticator_ReturnsRedirectToActionResult_WhenSucceeded()
{
SetGetUserAsyncMethod();
_userManagerMock
.Setup(ManageUsersController => ManageUsersController.GetAuthenticatorKeyAsync(It.IsAny <ApplicationUser>()))
.ReturnsAsync("test_string");
_userManagerMock
.Setup(ManageUsersController =>
ManageUsersController.VerifyTwoFactorTokenAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
_userManagerMock
.Setup(ManageUsersController =>
ManageUsersController.GenerateNewTwoFactorRecoveryCodesAsync(It.IsAny <ApplicationUser>(), It.IsAny <int>()))
.ReturnsAsync(new List <string>());
var result = await _manageController.EnableAuthenticator(new EnableAuthenticatorViewModel { Code = "Test code" });
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("ShowRecoveryCodes", redirectToActionResult.ActionName);
}
public void Setup()
{
mockManageUsers = new Mock <IManageUsers>();
manageUsersController = new ManageUsersController(mockManageUsers.Object);
}