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 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 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 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 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 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 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 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 async Task RemoveFromRole_WithRemoveFromRoleSuccessResult_ShouldShowErrorAndReturnToDetails()
{
string successMessage = null;
//Arrange
Mock <RoleManager <IdentityRole> > roleManager = RoleManagerMock.New();
roleManager
.Setup(r => r.RoleExistsAsync(role))
.ReturnsAsync(true);
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
userManager
.Setup(u => u.RemoveFromRoleAsync(user, role))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => successMessage = message as string);
UsersController usersController = new UsersController(roleManager.Object, userManager.Object, null, null, null)
{
TempData = tempData.Object
};
//Assert
var result = await usersController.RemoveFromRole(new UserWithRoleFormViewModel()
{
Role = role, Username = username
});
//Assert
successMessage.Should().Be(string.Format(RemoveFromRoleSuccessMessage, username, role));
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Details");
result.As <RedirectToActionResult>().RouteValues.Keys.Should().Contain("Username");
result.As <RedirectToActionResult>().RouteValues.Values.Should().Contain(username);
}
public async Task ChangePassworPost_WithCorrectUsernameAndUserWithPasswordAndPasswordModified_ShouldReturnSuccessMessageAndReturnToProfile()
{
string successMessage = null;
//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.ChangePasswordAsync(user, null, null))
.ReturnsAsync(true);
userService
.Setup(u => u.IsOldPasswordValid(user, null))
.ReturnsAsync(true);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => successMessage = message as string);
UsersController usersController = new UsersController(userManager.Object, userService.Object)
{
TempData = tempData.Object
};
//Assert
var result = await usersController.ChangePassword(username, new UserChangePasswordServiceModel());
//Assert
successMessage.Should().Be(UserChangePasswordSuccessMessage);
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 AddToRole_WithInvalidModelState_ShouldShowErrorAndReturnToDetails()
{
string errorMessage = null;
//Arrange
Mock <RoleManager <IdentityRole> > roleManager = RoleManagerMock.New();
roleManager
.Setup(r => r.RoleExistsAsync(role))
.ReturnsAsync(true);
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(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(roleManager.Object, userManager.Object, null, null, null)
{
TempData = tempData.Object
};
usersController.ModelState.AddModelError(string.Empty, "Error");
//Assert
var result = await usersController.AddToRole(new UserWithRoleFormViewModel()
{
Role = role, Username = username
});
//Assert
errorMessage.Should().Be(InvalidIdentityDetailsErroMessage);
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Details");
result.As <RedirectToActionResult>().RouteValues.Keys.Should().Contain("Username");
result.As <RedirectToActionResult>().RouteValues.Values.Should().Contain(username);
}
public async Task Order_WithShoppingCartWithoutSupplements_ShouldReturnToHomeIndex()
{
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns(authorId);
ShoppingCart shoppingCart = new ShoppingCart()
{
Supplements = new List <SupplementInCartServiceModel>()
};
byte[] shoppingCartAsByteArray = System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(shoppingCart));
Mock <ISession> session = new Mock <ISession>();
session
.Setup(s => s.TryGetValue(UserSessionShoppingCartKey, out shoppingCartAsByteArray))
.Returns(true);
Mock <HttpContext> httpContext = new Mock <HttpContext>();
httpContext
.SetupGet(h => h.Session)
.Returns(session.Object);
OrdersController ordersController = new OrdersController(userManager.Object, null, null)
{
ControllerContext = new ControllerContext
{
HttpContext = httpContext.Object
}
};
//Act
var result = await ordersController.Order();
//Assert
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
result.As <RedirectToActionResult>().ControllerName.Should().Be("Home");
}
private Mock <UserManager <User> > GetUserManagerMock()
{
var userManager = UserManagerMock.New();
userManager
.Setup(u => u.GetUsersInRoleAsync(It.IsAny <string>()))
.ReturnsAsync(new List <User>
{
new User {
Id = FirstUserId, UserName = FirstUserName
},
new User {
Id = SecondUserId, UserName = SecondUserName
}
});
return(userManager);
}
public async Task ChangePassworPost_WithCorrectUsernameAndUserWithPasswordAndPasswordNotModified_ShouldReturnWarningMessageAndReturnValidViewModel()
{
string warningMessage = null;
//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.ChangePasswordAsync(user, null, null))
.ReturnsAsync(false);
userService
.Setup(u => u.IsOldPasswordValid(user, null))
.ReturnsAsync(true);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataWarningMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => warningMessage = message as string);
UsersController usersController = new UsersController(userManager.Object, userService.Object)
{
TempData = tempData.Object
};
//Assert
var result = await usersController.ChangePassword(username, new UserChangePasswordServiceModel());
//Assert
warningMessage.Should().Be(EntityNotModified);
result.Should().BeOfType <ViewResult>();
result.As <ViewResult>().Model.Should().BeOfType <UserChangePasswordServiceModel>();
}
public async Task Orders_WithCorrectPage_ShouldReturnViewResultWithValidViewModel()
{
const int page = 3;
const int totalElements = 10;
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
Mock <IAdminUserService> adminUserService = new Mock <IAdminUserService>();
adminUserService
.Setup(a => a.GetOrdersByUsernameAsync(username, page))
.ReturnsAsync(new AdminUserOrdersServiceModel());
Mock <IUserService> userService = new Mock <IUserService>();
userService
.Setup(u => u.TotalOrdersAsync(username))
.ReturnsAsync(totalElements);
UsersController usersController = new UsersController(null, userManager.Object, adminUserService.Object, userService.Object, null);
//Assert
var result = await usersController.Orders(username, page);
//Assert
result.Should().BeOfType <ViewResult>();
result.As <ViewResult>().Model.Should().BeOfType <PagingElementViewModel <AdminUserOrdersServiceModel> >();
PagingElementViewModel <AdminUserOrdersServiceModel> model = result.As <ViewResult>().Model.As <PagingElementViewModel <AdminUserOrdersServiceModel> >();
model.Pagination.CurrentPage.Should().Be(page);
model.Pagination.PreviousPage.Should().Be(2);
model.Pagination.NextPage.Should().Be(4);
model.Pagination.TotalPages.Should().Be(4);
model.Pagination.TotalElements.Should().Be(totalElements);
model.Pagination.PageSize.Should().Be(OrderPageSize);
}
public async Task Orders_WithPageLessThanOneOrEqualToZero_ShouldReturnToOrders(int page)
{
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
UsersController usersController = new UsersController(null, userManager.Object, null, null, null);
//Act
var result = await usersController.Orders(username, page);
//Assert
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Orders");
result.As <RedirectToActionResult>().RouteValues.Keys.Should().Contain("username");
result.As <RedirectToActionResult>().RouteValues.Values.Should().Contain(username);
}
public async Task Profile_WithTotalPagesEqualToOne_ShouldReturnValidPaginationModelAndValidViewModel()
{
const int page = 1;
const int totalElements = OrderPageSize;
//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 <ViewResult>();
result.As <ViewResult>().Model.Should().BeOfType <PagingElementViewModel <UserProfileServiceModel> >();
PagingElementViewModel <UserProfileServiceModel> model = result.As <ViewResult>().Model.As <PagingElementViewModel <UserProfileServiceModel> >();
model.Pagination.CurrentPage.Should().Be(page);
model.Pagination.PreviousPage.Should().Be(page);
model.Pagination.NextPage.Should().Be(page);
model.Pagination.TotalPages.Should().Be(page);
model.Pagination.TotalElements.Should().Be(totalElements);
model.Pagination.PageSize.Should().Be(OrderPageSize);
}
public async Task ChangePasswordPost_WithUserWithoutPassword_ShouldReturnErrorMessageAndReturnToProfile()
{
string errorMessage = null;
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(username))
.ReturnsAsync(user);
userManager
.Setup(u => u.HasPasswordAsync(user))
.ReturnsAsync(false);
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.ChangePassword(username, new UserChangePasswordServiceModel());
//Assert
errorMessage.Should().Be(UserChangePasswordExternalLoginErrorMessage);
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 ProfileShouldReturnViewWithValidModelWithValidUserName()
{
//Arrenge
const string userId = "SomeId";
const string userName = "******";
var userManager = UserManagerMock.New();
userManager
.Setup(u => u.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(new User {
Id = userId
});
var userService = new Mock <IUserService>();
userService
.Setup(u => u.ProfileAsync(It.Is <string>(id => id == userId)))
.ReturnsAsync(new UserProfileServiceModel {
UserName = userName
});
var controller = new UsersController(userService.Object, userManager.Object);
//Act
var result = await controller.Profile(userName);
//Assert
result
.Should()
.BeOfType <ViewResult>()
.Subject
.Model
.Should()
.Match(m => m.As <UserProfileServiceModel>().UserName == userName);
}
public async Task Order_WithSuccessResult_ShouldReturnToHomeIndex()
{
string successMessage = null;
//Arrange
Mock <UserManager <User> > userManager = UserManagerMock.New();
userManager
.Setup(u => u.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns(authorId);
Mock <IOrderService> orderService = new Mock <IOrderService>();
orderService
.Setup(o => o.FinishOrderAsync(authorId, It.IsAny <ShoppingCart>()))
.ReturnsAsync(true);
ShoppingCart shoppingCart = new ShoppingCart()
{
Supplements = new List <SupplementInCartServiceModel>()
{
new SupplementInCartServiceModel()
}
};
byte[] shoppingCartAsByteArray = System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(shoppingCart));
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => successMessage = message as string);
Mock <ISession> session = new Mock <ISession>();
session
.Setup(s => s.TryGetValue(UserSessionShoppingCartKey, out shoppingCartAsByteArray))
.Returns(true);
Mock <HttpContext> httpContext = new Mock <HttpContext>();
httpContext
.SetupGet(h => h.Session)
.Returns(session.Object);
OrdersController ordersController = new OrdersController(userManager.Object, orderService.Object, null)
{
TempData = tempData.Object,
ControllerContext = new ControllerContext
{
HttpContext = httpContext.Object
}
};
//Act
var result = await ordersController.Order();
//Assert
successMessage.Should().Be(FinishOrderSuccessMessage);
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("Index");
result.As <RedirectToActionResult>().ControllerName.Should().Be("Home");
}
