public async Task Orders_WithIncorrectUsername_ShouldReturnToIndex()
{
string errorMessage = null;
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(default(User));
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataErrorMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => errorMessage = message as string);
UsersController usersController = new UsersController(null, userManager.Object, null, null, null)
{
TempData = tempData.Object
};
//Act
var result = await usersController.Orders(username);
//Assert
errorMessage.Should().Be(string.Format(EntityNotFound, UserEntity));
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
}
public async Task Edit_Not_Admin()
{
IdentityUser[] users = new IdentityUser[]
{
new IdentityUser("User1")
{
Id = "9E922BD2-4395-4524-8264-4F218D600E9D", Email = "*****@*****.**"
},
new IdentityUser("User2")
{
Id = "4192883F-AA46-42EA-B1DD-73E8CAA7A7B3", Email = "*****@*****.**"
}
};
UnitOfWorkMock.Setup(m => m.Customers.GetItem(It.IsAny <Guid>()))
.Returns(new Customer()
{
Name = "NameCustomer"
});
UserManagerMock.Setup(m => m.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(users[0]);
UserManagerMock.Setup(m => m.IsInRoleAsync(It.IsAny <IdentityUser>(), "Admin")).ReturnsAsync(false);
var target = new UserController(UserManagerMock.Object, null, null, null, UnitOfWorkMock.Object, null);
var resultAction = await target.Edit(Guid.Parse(users[0].Id));
var resultModel = (resultAction as ViewResult).Model as UserInfoViewModel;
Assert.True(resultModel.IsAdmin == false);
Assert.True(resultModel.Customer.Name == "NameCustomer");
Assert.True(resultModel.Email == "*****@*****.**");
}
public async Task Update_User()
{
UserManagerMock.Setup(m => m.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(new IdentityUser());
UserManagerMock.Setup(m => m.UpdateAsync(It.IsAny <IdentityUser>()))
.ReturnsAsync(IdentityResult.Success);
UserValidatorMock.Setup(m => m.ValidateAsync(UserManagerMock.Object, It.IsAny <IdentityUser>()))
.ReturnsAsync(IdentityResult.Success);
UnitOfWorkMock.Setup(um => um.Customers.UpdateItem(It.IsAny <Customer>())).Verifiable();
UnitOfWorkMock.Setup(um => um.SaveChanges()).Verifiable();
var target = new UserController(UserManagerMock.Object, null, null, UserValidatorMock.Object,
UnitOfWorkMock.Object, null);
var resultAction = await target.Create(new UserInfoViewModel()
{
Customer = new Customer(),
Email = "*****@*****.**",
Password = "******",
IsAdmin = false
}) as RedirectToActionResult;
Assert.NotNull(resultAction);
UnitOfWorkMock.Verify(e => e.SaveChanges());
UnitOfWorkMock.Verify(e => e.Customers.UpdateItem(It.IsAny <Customer>()));
}
public async Task Profile_WithPageBiggerThanOneAndBiggerThanTotalPages_ShouldReturnToIndex()
{
const int page = 10;
const int totalElements = 10;
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
Mock <IUserService> userService = new Mock <IUserService>();
userService
.Setup(u => u.GetProfileByUsernameAsync(username, page))
.ReturnsAsync(new UserProfileServiceModel());
userService
.Setup(u => u.TotalOrdersAsync(username))
.ReturnsAsync(totalElements);
UsersController usersController = new UsersController(userManager.Object, userService.Object);
//Act
var result = await usersController.Profile(username, page);
//Assert
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Profile");
result.As <RedirectToActionResult>().RouteValues.Keys.Should().Contain("username");
result.As <RedirectToActionResult>().RouteValues.Values.Should().Contain(username);
}
public async Task WhenSuccessfulReturnsTrue()
{
UserManagerMock.Setup(um => um.GenerateEmailConfirmationTokenAsync(It.IsAny <GametekiUser>())).ReturnsAsync("Code");
var result = await Service.SendActivationEmailAsync(TestUtils.GetRandomUser(), new AccountVerificationModel());
Assert.IsTrue(result);
}
public async Task Change_Password_Some_Error()
{
UserManagerMock.Setup(m => m.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(new IdentityUser());
UserManagerMock.Setup(m => m.CheckPasswordAsync(It.IsAny <IdentityUser>(), It.IsAny <string>()))
.ReturnsAsync(true);
UserManagerMock.Setup(m => m.ChangePasswordAsync(It.IsAny <IdentityUser>(),
It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed());
PasswordValidatorMock.Setup(m => m.ValidateAsync(UserManagerMock.Object,
It.IsAny <IdentityUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
var target = new AccountController(UserManagerMock.Object,
SignInManagerMock.Object, PasswordValidatorMock.Object);
var result = await target.ChangePassword(new PasswordChangeViewModel()
{
NewPassword = "******",
RepeatNewPassword = "******"
}) as ViewResult;
Assert.NotNull(result);
Assert.False(target.ModelState.IsValid);
Assert.True(target.ModelState[""].Errors[0].ErrorMessage == "Произошла ошибка, повторите попытку");
}
public async Task EditProfileGet_WithCorrectUsername_ShouldReturnValidViewModel()
{
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
Mock <IUserService> userService = new Mock <IUserService>();
userService
.Setup(u => u.GetEditProfileByUsernameAsync(username))
.ReturnsAsync(new UserEditProfileServiceModel());
UsersController usersController = new UsersController(userManager.Object, userService.Object);
//Assert
var result = await usersController.EditProfile(username);
//Assert
result.Should().BeOfType <ViewResult>();
result.As <ViewResult>().Model.Should().BeOfType <UserEditProfileServiceModel>();
}
public async Task Permission_WithIncorrectUsername_ShouldReturnErrorMessageAndReturntoIndex()
{
string errorMessage = null;
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(default(User));
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataErrorMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => errorMessage = message as string);
UsersController usersController = new UsersController(userManager.Object, null)
{
TempData = tempData.Object
};
//Assert
var result = await usersController.Permission(username);
//Assert
errorMessage.Should().Be(InvalidIdentityDetailsErroMessage);
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
}
public async Task Permission_WithCorrectUsername_ShouldReturnToIndex()
{
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
Mock <IModeratorUserService> moderatorUserService = new Mock <IModeratorUserService>();
moderatorUserService
.Setup(m => m.ChangePermission(user))
.Returns(Task.CompletedTask);
UsersController usersController = new UsersController(userManager.Object, moderatorUserService.Object);
//Assert
var result = await usersController.Permission(username);
//Assert
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
}
public async Task ChangePasswordGet_WithCorrectUsernameAndUserWithPassword_ShouldReturnValidViewModel()
{
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
userManager
.Setup(u => u.HasPasswordAsync(user))
.ReturnsAsync(true);
Mock <IUserService> userService = new Mock <IUserService>();
userService
.Setup(u => u.GetChangePasswordByUsernameAsync(username))
.ReturnsAsync(new UserChangePasswordServiceModel());
UsersController usersController = new UsersController(userManager.Object, userService.Object);
//Assert
var result = await usersController.ChangePassword(username);
//Assert
result.Should().BeOfType <ViewResult>();
result.As <ViewResult>().Model.Should().BeOfType <UserChangePasswordServiceModel>();
}
public async Task AddUserPost_ShouldReturnRedirectToActionWhenModelStateIsValid()
{
// Arrange
string tempDataSuccessMessage = null;
RegisterViewModel formModel = new RegisterViewModel()
{
Email = FirstUserEmail,
Username = FirstUserUsername,
};
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
userManager
.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t["SuccessMessage"] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
HomeController controller = new HomeController(null, userManager.Object, null);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.AddUser(formModel);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("AllUsers");
tempDataSuccessMessage.Should().Be(AddUserMessageSuccessfull);
}
public async Task AddUserPost_ShouldReturnViewWithModelWhenCreateAsyncFailed()
{
// Arrange
RegisterViewModel formModel = new RegisterViewModel()
{
Username = "******"
};
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
userManager
.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "test"
}));
HomeController controller = new HomeController(null, userManager.Object, null);
// Act
IActionResult actionResult = await controller.AddUser(formModel);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <RegisterViewModel>();
var returnedModel = model.As <RegisterViewModel>();
returnedModel.Username.Should().Be(formModel.Username);
}
public async Task AddUser_AfterAdded_Success()
{
AddUserService addUserService = new AddUserService(
UserManagerMock.Create().WithCreateSuccess().Object,
SignInManagerMock.Create().Object,
IEmailConfirmationServiceMock.Create().SendVerificationMailSuccess().Object,
IGroupUserServiceMock.Create().Object,
IAddUserFilterMock.Create().BeforeAdd_Success().AfterAdded_Success().Object,
IBaseDAOMock<AppUserEntity>.Create().Object,
IBaseDAOMock<InviteEntity>.Create().Object,
IBaseDAOMock<RoleEntity>.Create().Object,
IOptionsMock<IdentityUIEndpoints>.Create().DefaultValue().Object,
IValidatorMock<NewUserRequest>.Create().Object,
IValidatorMock<RegisterRequest>.Create().Object,
IValidatorMock<AcceptInviteRequest>.Create().Object,
IValidatorMock<ExternalLoginRegisterRequest>.Create().Object,
IValidatorMock<GroupBaseUserRegisterRequest>.Create().Object,
IValidatorMock<BaseRegisterRequest>.Create().Validate_Valid().Object,
IValidatorMock<IUserAttributeRequest>.Create().Validate_Valid().Object,
NullLogger<AddUserService>.Instance);
BaseRegisterRequest baseRegisterRequest = new Fixture()
.Build<BaseRegisterRequest>()
.Create();
Result<AppUserEntity> result = await addUserService.AddUser(baseRegisterRequest);
result.Success.Should().BeTrue();
}
public async Task WhenCreateReturnsSuccessReturnsTrue()
{
UserManagerMock.Setup(um => um.CreateAsync(It.IsAny <GametekiUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
var result = await Service.RegisterUserAsync(TestUtils.GetRandomAccount(), "password");
Assert.IsTrue(result.Success);
}
public async Task WhenCreateThrowsExceptionReturnsFalse()
{
UserManagerMock.Setup(um => um.CreateAsync(It.IsAny <GametekiUser>(), It.IsAny <string>())).ThrowsAsync(new Exception());
var result = await Service.RegisterUserAsync(TestUtils.GetRandomAccount(), "password");
Assert.IsFalse(result.Success);
}
public async Task WhenTokenGenerateFailsReturnsFalse()
{
UserManagerMock.Setup(um => um.GenerateEmailConfirmationTokenAsync(It.IsAny <GametekiUser>())).ThrowsAsync(new Exception());
var result = await Service.SendActivationEmailAsync(TestUtils.GetRandomUser(), new AccountVerificationModel());
Assert.IsFalse(result);
}
public CoursesContollerCategoryTests()
{
this.db = new CoursesP2PDbContext(MemoryDatabase.OptionBuilder());
this.userManager = UserManagerMock.UserManagerMockTest();
this.coursesService = new CoursesService(db);
this.coursesController = new CoursesController(coursesService, reviewService, userManager, null, null);
}
public async Task WhenPasswordChangeSucceedsReturnsTrue()
{
UserManagerMock.Setup(um => um.ChangePasswordAsync(It.IsAny <GametekiUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
var result = await Service.UpdateUserAsync(new GametekiUser(), "old", "new");
Assert.IsTrue(result.Succeeded);
}
public async Task WhenConfirmEmailSucceedsReturnsTrue()
{
UserManagerMock.Setup(um => um.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
UserManagerMock.Setup(um => um.ConfirmEmailAsync(It.IsAny <GametekiUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
var result = await Service.ValidateUserAsync("UserId", "token");
Assert.IsTrue(result);
}
public async Task WhenRenderFailsReturnsFalse()
{
UserManagerMock.Setup(um => um.GenerateEmailConfirmationTokenAsync(It.IsAny <GametekiUser>())).ReturnsAsync("Code");
ViewRenderServiceMock.Setup(vr => vr.RenderToStringAsync(It.IsAny <string>(), It.IsAny <AccountVerificationModel>())).ThrowsAsync(new Exception());
var result = await Service.SendActivationEmailAsync(TestUtils.GetRandomUser(), new AccountVerificationModel());
Assert.IsFalse(result);
}
public async Task WhenIncorrectPasswordReturnsNull()
{
var user = TestUsers.First();
UserManagerMock.Setup(um => um.CheckPasswordAsync(It.IsAny <GametekiUser>(), It.IsAny <string>())).ReturnsAsync(false);
var result = await Service.LoginUserAsync(user.UserName, "password", "127.0.0.1");
Assert.IsNull(result);
}
public async Task ChangeUserRolesPost_ShouldReturnNotFoundWhenInvalidUserId()
{
// Arrange
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
UsersController controller = new UsersController(null, null, userManager.Object);
// Act
IActionResult actionResult = await controller.ChangeUserRoles(InvalidUserId, new ChangeUserRolesFormModel());
// Assert
actionResult.Should().BeOfType <NotFoundResult>();
}
public async Task ManageRolesPost_ShouldReturnNotFoundWhenInvalidUserId()
{
// Arrange
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
HomeController controller = new HomeController(null, userManager.Object, null);
// Act
IActionResult actionResult = await controller.ManageRoles(InvalidUserId, new IdentityRoleViewModel());
// Assert
actionResult.Should().BeOfType <NotFoundResult>();
}
public async Task DeleteUserPost_ShouldReturnNotFoundWhenInvalidUserId()
{
// Arrange
Mock <UserManager <User> > userManager = UserManagerMock.GetNew();
HomeController controller = new HomeController(null, userManager.Object, null);
// Act
IActionResult actionResult = await controller.DeleteUser(InvalidUserId);
// Assert
actionResult.Should().BeOfType <NotFoundResult>();
}
public async Task WhenCorrectPasswordReturnsResult()
{
var user = TestUsers.First();
UserManagerMock.Setup(um => um.CheckPasswordAsync(It.IsAny <GametekiUser>(), It.IsAny <string>())).ReturnsAsync(true);
var result = await Service.LoginUserAsync(user.UserName, "password", "127.0.0.1");
Assert.IsNotNull(result);
Assert.AreEqual(user, result.User);
Assert.IsNotNull(result.Token);
Assert.IsNotNull(result.RefreshToken);
}
public static Mock <SignInManager <User> > CreateMock()
{
var mock = new Mock <SignInManager <User> >(
UserManagerMock.CreateMock().Object,
new HttpContextAccessor(),
new Mock <IUserClaimsPrincipalFactory <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <ILogger <SignInManager <User> > >().Object,
new Mock <IAuthenticationSchemeProvider>().Object,
new Mock <IUserConfirmation <User> >().Object);
return(mock);
}
public async Task Details_WithCorrectUsername_ShouldReturnValidViewModel()
{
//Arrange
IQueryable <IdentityRole> roles = new List <IdentityRole>()
{
new IdentityRole("firstRole"), new IdentityRole("secondRole"), new IdentityRole("thirdRole")
}.AsQueryable();
Mock <RoleManager <IdentityRole> > roleManager = RoleManagerMock.New();
roleManager
.Setup(r => r.Roles)
.Returns(roles);
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
userManager
.Setup(u => u.GetRolesAsync(user))
.ReturnsAsync(new List <string>()
{
"firstRole", "secondRole", "thirdRole"
});
Mock <IAdminUserService> adminUserService = new Mock <IAdminUserService>();
adminUserService
.Setup(a => a.GetDetailsByUsernameAsync(username))
.ReturnsAsync(new AdminUserDetailsServiceModel());
UsersController usersController = new UsersController(roleManager.Object, userManager.Object, adminUserService.Object, null, null);
//Assert
var result = await usersController.Details(username);
//Assert
result.Should().BeOfType <ViewResult>();
result.As <ViewResult>().Model.Should().BeOfType <AdminUserDetailsServiceModel>();
AdminUserDetailsServiceModel model = result.As <ViewResult>().Model.As <AdminUserDetailsServiceModel>();
model.CurrentRoles.First().Text.Should().Be(roles.First().Name);
model.CurrentRoles.First().Value.Should().Be(roles.First().Name);
model.CurrentRoles.Last().Text.Should().Be(roles.Last().Name);
model.CurrentRoles.Last().Value.Should().Be(roles.Last().Name);
model.AllRoles.Should().HaveCount(0);
}
public async Task Change_Password_Invalid_Old()
{
UserManagerMock.Setup(m => m.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(new IdentityUser());
UserManagerMock.Setup(m => m.CheckPasswordAsync(It.IsAny <IdentityUser>(), It.IsAny <string>()))
.ReturnsAsync(false);
var target = new AccountController(UserManagerMock.Object,
SignInManagerMock.Object, PasswordValidatorMock.Object);
var result = await target.ChangePassword(new PasswordChangeViewModel()) as ViewResult;
Assert.NotNull(result);
Assert.False(target.ModelState.IsValid);
Assert.True(target.ModelState[""].Errors[0].ErrorMessage == "Неправильный старый пароль");
}
public async Task ProfileShouldReturnNotFoundWithInvalidUserName()
{
//Arrenge
var userManager = UserManagerMock.New();
var controller = new UsersController(null, userManager.Object);
//Act
var result = await controller.Profile("Username");
//Assert
result.Should()
.BeOfType <NotFoundResult>();
}
public AccountServiceUnitTests()
{
_testUser = InMemoryDataGenerator.TestUser;
_context = InMemoryDataGenerator.CreateAndInitializeInMemoryDatabaseContext(Guid.NewGuid().ToString(), _testUser, insertIngredientData: false);
_userManager = UserManagerMock.MockUserManager <PantryPlannerUser>().Object;
_signInManager = new SignInManager <PantryPlannerUser>(_userManager
, new Mock <IHttpContextAccessor>().Object
, new Mock <IUserClaimsPrincipalFactory <PantryPlannerUser> >().Object
, new Mock <IOptions <IdentityOptions> >().Object
, new Mock <ILogger <SignInManager <PantryPlannerUser> > >().Object
, new Mock <IAuthenticationSchemeProvider>().Object);
_service = new AccountService(_userManager, _signInManager, null);
}
