private void CheckIfUserHasRightRole(User userToLogin)
{
if (!userToLogin.HasThisRole(AdminRole.GetInstance()))
{
throw new UnauthorizedAccessException();
}
}
public static void SetReservedProviderInfoForTests(TestContext testContext)
{
ADMIN_USER = new User("Brulu", ADMIN_USER_USEREMAIL, "HOLA1234", AdminRole.GetInstance());
List <IField> emptyFields = new List <IField>();
TextField field = new TextField("NumeroCliente");
emptyFields.Add(field);
DESIGNED_PROVIDER = new Provider("Apple", 3, emptyFields);
ProvidersController providerController = new ProvidersController(ADMIN_USER.Email);
providerController.PostProvider(DESIGNED_PROVIDER);
IHttpActionResult actionResultProvider = providerController.GetProviders();
OkNegotiatedContentResult <IEnumerable <Provider> > contentResult = (OkNegotiatedContentResult <IEnumerable <Provider> >)actionResultProvider;
IEnumerable <Provider> providers = contentResult.Content;
foreach (Provider provider in providers)
{
if (provider.Name.Equals(DESIGNED_PROVIDER.Name))
{
DESIGNED_PROVIDER.ID = provider.ID;
}
}
providerController.Dispose();
FIRST_PAYMENT = CreateFirstPayment();
SECOND_PAYMENT = CreateNewRandomPayment();
CONTROLLER = new PaymentsController(ADMIN_USER_USEREMAIL);
CONTROLLER.PostPayment(FIRST_PAYMENT);
CONTROLLER.PostPayment(SECOND_PAYMENT);
CONTROLLER.Dispose();
}
public void ReturnFalseWhenComparedWithANonRoleObject()
{
AdminRole adminRole = AdminRole.GetInstance();
string nonRoleObject = "Hello World!";
Assert.AreNotEqual(adminRole, nonRoleObject);
}
public void HaveItsNamesHashCode()
{
AdminRole adminRole = AdminRole.GetInstance();
int adminRoleHashCode = adminRole.GetHashCode();
Assert.AreEqual(adminRoleHashCode, adminRole.Name.GetHashCode());
}
public void NotCreateMultipleInstancesOfSameRole()
{
AdminRole firstAdminRole = AdminRole.GetInstance();
AdminRole secondAdminRole = AdminRole.GetInstance();
Assert.AreSame(firstAdminRole, secondAdminRole);
}
public void HaveAtLeastOnePrivilege()
{
AdminRole adminRole = AdminRole.GetInstance();
int numberOfPrivileges = adminRole.GetPrivilegeCount();
Assert.IsTrue(numberOfPrivileges > 0);
}
public void NotHaveANullName()
{
Role adminRole = AdminRole.GetInstance();
string email = "*****@*****.**";
string name = null;
string password = "******";
User notValidUser = new User(name, email, password, adminRole);
}
public void NotHaveANullEmail()
{
Role adminRole = AdminRole.GetInstance();
string email = null;
string name = "Nacho";
string password = "******";
User notValidUser = new User(name, email, password, adminRole);
}
public void NotHaveAnInvalidEmail()
{
Role adminRole = AdminRole.GetInstance();
string email = "invalid";
string name = "Diego";
string password = "******";
User notValidUser = new User(name, email, password, adminRole);
}
public void NotHaveAnEmptyName()
{
Role adminRole = AdminRole.GetInstance();
string email = "*****@*****.**";
string name = "";
string password = "******";
User notValidUser = new User(name, email, password, adminRole);
}
public void KnowIfItHasACertainPrivilege()
{
AdminRole adminRole = AdminRole.GetInstance();
ICollection <Privilege> adminPrivileges = adminRole.Privileges;
Privilege firstPrivilege = adminPrivileges.ElementAt(FIRST_POSITION);
Assert.IsTrue(adminRole.HasPrivilege(firstPrivilege));
}
public void NotHaveAWhiteSpaceName()
{
Role adminRole = AdminRole.GetInstance();
string email = "*****@*****.**";
string name = " ";
string password = "******";
User notValidUser = new User(name, email, password, adminRole);
}
public void KnowIfHeDoesntHaveAGivenRole()
{
Role cashierRole = CashierRole.GetInstance();
Role adminRole = AdminRole.GetInstance();
string userEmail = "*****@*****.**";
string userName = "******";
string password = "******";
User newUser = new User(userName, userEmail, password, cashierRole);
Assert.IsFalse(newUser.HasThisRole(adminRole));
}
public void BeAbleToGetAnObjectByID()
{
User user = new User("Bruno", "*****@*****.**", "Hola111!!!", AdminRole.GetInstance());
var mockContext = new Mock <TodoPagosContext>();
mockContext.Setup(ctx => ctx.Set <User>().Find(It.IsAny <int>())).Returns(user);
GenericRepository <User> repository = new GenericRepository <User>(mockContext.Object);
User resultingUser = repository.GetByID(0);
Assert.AreEqual(user, resultingUser);
}
public void BeAbleToAddRoles()
{
Role cashierRole = CashierRole.GetInstance();
Role adminRole = AdminRole.GetInstance();
string userEmail = "*****@*****.**";
string userName = "******";
string password = "******";
User newUser = new User(userName, userEmail, password, cashierRole);
newUser.AddRole(adminRole);
Assert.IsTrue(newUser.HasThisRole(adminRole) && newUser.HasThisRole(cashierRole));
}
public void KnowIfItHasACertainPrivilege()
{
Role adminRole = AdminRole.GetInstance();
string userEmail = "*****@*****.**";
string userName = "******";
string password = "******";
User newUser = new User(userName, userEmail, password, adminRole);
ICollection <Privilege> adminPrivileges = adminRole.Privileges;
Privilege firstPrivilege = adminPrivileges.ElementAt(FIRST_POSITION);
Assert.IsTrue(newUser.HasPrivilege(firstPrivilege));
}
public static void SetReservedProviderInfoForTests(TestContext testContext)
{
ADMIN_USER = new User("Brulu", ADMIN_USER_USEREMAIL, "HOLA1234", AdminRole.GetInstance());
RESERVED_PROVIDER = new Provider("Claro", 5, new List <IField>());
MODIFICABLE_PROVIDER = new Provider("Movistar", 10, new List <IField>());
CONTROLLER = new ProvidersController(ADMIN_USER.Email);
CONTROLLER.PostProvider(MODIFICABLE_PROVIDER);
CONTROLLER.PostProvider(RESERVED_PROVIDER);
CONTROLLER.Dispose();
}
public void BeAbleToRemoveRoles()
{
Role cashierRole = CashierRole.GetInstance();
Role adminRole = AdminRole.GetInstance();
string userEmail = "*****@*****.**";
string userName = "******";
string password = "******";
User newUser = new User(userName, userEmail, password, cashierRole);
newUser.AddRole(adminRole);
newUser.RemoveRole(cashierRole);
Assert.IsFalse(newUser.HasThisRole(cashierRole));
}
public void BeAbleToDeleteUserFromRepository()
{
User adminUser = new User("Bruno", "*****@*****.**", "Hola123!!", AdminRole.GetInstance());
adminUser.ID = 1;
var mockUnitOfWork = new Mock <IUnitOfWork>();
SetMockDeleteRoutine1(mockUnitOfWork, adminUser);
UserService userService = new UserService(mockUnitOfWork.Object);
bool deleted = userService.DeleteUser(1, adminUser.Email);
mockUnitOfWork.Verify(un => un.UserRepository.Delete(It.IsAny <int>()), Times.Exactly(1));
mockUnitOfWork.Verify(un => un.Save(), Times.Exactly(1));
Assert.IsTrue(deleted);
}
public static void SetAdminInfoForTests(TestContext testContext)
{
ADMIN_USER = new User("Brulu", ADMIN_USER_USEREMAIL, "HOLA1234", AdminRole.GetInstance());
ADMIN_USER.ID = 1;
ProvidersController providersController = new ProvidersController(ADMIN_USER_USEREMAIL);
OkNegotiatedContentResult <Provider> result =
(OkNegotiatedContentResult <Provider>)providersController.GetProvider(1);
FIRST_TEST_PROVIDER = result.Content;
result = (OkNegotiatedContentResult <Provider>)providersController.GetProvider(2);
SECOND_TEST_PROVIDER = result.Content;
}
public void BeAbleToReturnAllUsersInRepository()
{
List <User> allUsers = new List <User>
{
new User("Gabriel", "*****@*****.**", "Wololo1234!", CashierRole.GetInstance()),
new User("Ignacio", "*****@*****.**", "#designPatternsLover123", AdminRole.GetInstance())
};
var mockUserService = new Mock <IUserService>();
mockUserService.Setup(x => x.GetAllUsers(It.IsAny <string>())).Returns(allUsers);
UsersController controller = new UsersController(mockUserService.Object);
IHttpActionResult actionResult = controller.GetUsers();
OkNegotiatedContentResult <IEnumerable <User> > contentResult = (OkNegotiatedContentResult <IEnumerable <User> >)actionResult;
Assert.IsTrue(contentResult.Content.All(x => allUsers.Contains(x)) &&
allUsers.All(x => contentResult.Content.Contains(x)));
}
public void BeAbleToGetAllObjectsWhileApplyingAFilterAndIncludingPropertiesPlusOrderingBy()
{
User user = new User("Bruno", "*****@*****.**", "Hola111!!!", AdminRole.GetInstance());
User anotherUser = new User("Alberto", "*****@*****.**", "Hola111!!!", AdminRole.GetInstance());
List <User> data = new List <User>();
data.Add(user);
data.Add(anotherUser);
var mockContext = new Mock <TodoPagosContext>();
var set = new Mock <DbSet <User> >().SetupData(data);
mockContext.Setup(ctx => ctx.Set <User>()).Returns(set.Object);
GenericRepository <User> repository = new GenericRepository <User>(mockContext.Object);
IEnumerable <User> resultingUsers = repository.Get((x => x.HasThisRole(AdminRole.GetInstance())),
(x => x.AsQueryable().OrderBy(u => u.Name)), "Roles");
Assert.AreEqual(2, resultingUsers.Count());
}
public void InsertTestsUserInfoForTest()
{
CONTROLLER = new UsersController(ADMIN_USER_USEREMAIL);
TESTS_USERS = new[]
{
new User("Gabriel", "*****@*****.**", "Wololo1234!", CashierRole.GetInstance()),
new User("Ignacio", "*****@*****.**", "#designPatternsLover123", AdminRole.GetInstance())
};
foreach (User aTestUser in TESTS_USERS)
{
CONTROLLER.PostUser(aTestUser);
}
ICollection <User> reservedUsers = new[] { ADMIN_USER };
ALL_USERS_IN_REPOSITORY = reservedUsers.Concat(TESTS_USERS).ToList();
}
public void BeAbleToReturnAllRolesOfASingleUserInRepository()
{
User singleUser = new User("Diego", "*****@*****.**", "#ElBizagra1995", AdminRole.GetInstance());
IEnumerable <User> user = new List <User> {
singleUser
};
var mockUnitOfWork = new Mock <IUnitOfWork>();
IEnumerable <string> roles = new List <string>()
{
"Admin"
};
mockUnitOfWork.Setup(un => un.UserRepository.Get(It.IsAny <Expression <Func <User, bool> > >(), null, "")).Returns(user);
UserService userService = new UserService(mockUnitOfWork.Object);
IEnumerable <string> returnedRoles = userService.GetRolesOfUser(singleUser.Email, singleUser.Email);
mockUnitOfWork.VerifyAll();
CollectionAssert.AreEqual((ICollection)roles, (ICollection)returnedRoles);
}
public void BeAbleToReturnSingleUserInRepository()
{
User singleUser = new User("Diego", "*****@*****.**", "#ElBizagra1995", AdminRole.GetInstance());
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(un => un.UserRepository.GetByID(singleUser.ID)).Returns(singleUser);
mockUnitOfWork
.Setup(un => un.CurrentSignedInUserHasRequiredPrivilege(singleUser.Email, UserManagementPrivilege.GetInstance()))
.Returns(true);
UserService userService = new UserService(mockUnitOfWork.Object);
User returnedUser = userService.GetSingleUser(singleUser.ID, singleUser.Email);
mockUnitOfWork.VerifyAll();
Assert.AreSame(singleUser, returnedUser);
}
public void NotDeleteAnythingIfSignedInUserAsksToDeleteHimself()
{
var mockUnitOfWork = new Mock <IUnitOfWork>();
User user = new User("Bruno", "*****@*****.**", "Holaaaa12!", AdminRole.GetInstance());
SetMockDeleteRoutine3(mockUnitOfWork, user);
UserService userService = new UserService(mockUnitOfWork.Object);
bool deleted = userService.DeleteUser(user.ID, It.IsAny <string>());
mockUnitOfWork.Verify(un => un.UserRepository.Delete(It.IsAny <int>()), Times.Never());
mockUnitOfWork.Verify(un => un.Save(), Times.Never());
Assert.IsFalse(deleted);
}
public void FailWithUnauthorizedAccessExceptionIfUserTriesToPostANewUserWithoutHavingUserManagementPrivilege()
{
User userToCreate = new User("Bruno", "*****@*****.**", "#ElBizagra1995", AdminRole.GetInstance());
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork
.Setup(un => un.CurrentSignedInUserHasRequiredPrivilege(It.IsAny <string>(), UserManagementPrivilege.GetInstance()))
.Returns(false);
UserService userService = new UserService(mockUnitOfWork.Object);
int id = userService.CreateUser(userToCreate, It.IsAny <string>());
}
private void SetMockUpdateRoutine6(Mock <IUnitOfWork> mockUnitOfWork)
{
User userWithSameEmail = new User("Bruno", "*****@*****.**", "#ElBizagrita1996", AdminRole.GetInstance());
userWithSameEmail.ID = 5;
mockUnitOfWork
.Setup(un => un.UserRepository.GetByID(It.IsAny <int>()))
.Returns(() => new User());
mockUnitOfWork
.Setup(un => un.CurrentSignedInUserHasRequiredPrivilege(It.IsAny <string>(), UserManagementPrivilege.GetInstance()))
.Returns(true);
mockUnitOfWork
.Setup(un => un.UserRepository.Get(
It.IsAny <System.Linq.Expressions.Expression <Func <User, bool> > >(), null, ""))
.Returns(new[] { userWithSameEmail });
}
public void NotUpdateUserWithEmailOfAnotherUserInRepository()
{
User updatedUserInfo = new User("Diego", "*****@*****.**", "#ElBizagra1995", AdminRole.GetInstance());
var mockUnitOfWork = new Mock <IUnitOfWork>();
SetMockUpdateRoutine6(mockUnitOfWork);
UserService userService = new UserService(mockUnitOfWork.Object);
bool updated = userService.UpdateUser(updatedUserInfo.ID + 1, updatedUserInfo, It.IsAny <string>());
mockUnitOfWork.Verify(un => un.UserRepository.Update(It.IsAny <User>()), Times.Never());
mockUnitOfWork.Verify(un => un.Save(), Times.Never());
Assert.IsFalse(updated);
}
public void BeAbleToGetAllUsersFromRepository()
{
User singleUser = new User("Diego", "*****@*****.**", "#ElBizagra1995", AdminRole.GetInstance());
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork
.Setup(un => un.CurrentSignedInUserHasRequiredPrivilege(singleUser.Email, UserManagementPrivilege.GetInstance()))
.Returns(true);
mockUnitOfWork.Setup(un => un.UserRepository.Get(null, null, ""));
UserService userService = new UserService(mockUnitOfWork.Object);
IEnumerable <User> returnedUsers = userService.GetAllUsers(singleUser.Email);
mockUnitOfWork.VerifyAll();
}