public UserForListingModel Map(User user)
 {
     return new UserForListingModel()
     {
         Id = user.Id,
         Name = user.Name
     };
 }
예제 #2
0
 public LoggedUserModel FromUserToUserLoginApi(User userToMapp)
 {
     LoggedUserModel userLoginApi = new LoggedUserModel();
     userLoginApi.Name = userToMapp.Name;
     userLoginApi.Id = userToMapp.Id;
     userLoginApi.EMail = userToMapp.Email;
     return userLoginApi;
 }
예제 #3
0
        public User Map(NewUser source)
        {
            User user = new User();
            user.Name = source.Login;
            user.Password = source.Password;
            user.EMail = source.Email;

            return user;
        }
        [Test]//Work +
        public void VerifyPassword_IsFalse_Test()
        {
            User user = new User { Password = "******" };
            //You can't mocked PasswordHasher becouse it's a class, not a interface
            //Mock<PasswordHasher> passHesher = new Mock<PasswordHasher>();
            // passHesher.Setup(t => t.VerifyHashedPassword(It.IsAny<string>(), It.IsAny<string>())).Returns(PasswordVerificationResult.Success);
            //passHesher.Setup(t => t.HashPassword("asdasdasd")).Returns("D8A928B2043DB77E340B523547BF16CB4AA483F0645FE0A290ED1F20AAB76257");
            // passHesher.CallBase = true;
            PasswordHasher ph = new PasswordHasher();
            string userFromDb = ph.HashPassword("ajjkks");

            var result = usServ.VerifyPasswords(userFromDb, user.Password);
            Assert.IsFalse(result);
        }
예제 #5
0
 public bool ChangeRolesOfUser(User user)
 {
     using (var context = new WorldOfWordsDatabaseContext())
     {
         User userToChange = context.Users.Include("Roles").Where(item => item.Id == user.Id).FirstOrDefault();
         userToChange.Roles = new List<Role>();
         var queryOfNeededIds = user.Roles.Select(item => item.Id);
         var toAdd = context.Roles.Where(item => queryOfNeededIds.Contains(item.Id)).ToList();
         foreach (var a in toAdd)
         {
             userToChange.Roles.Add(a);
         }
         context.SaveChanges();
     }
     return true;
 }
예제 #6
0
 public void Map_FieldsAreEqual()
 {
     //Arrange
     var initial = new RegisterUserModel
     {
         Email = "*****@*****.**",
         Login = "******",
         Password = "******"
     };
     var expected = new User
     {
         Email = "*****@*****.**",
         Name = "Roman",
         Password = "******"
     };
     //Act
     var actual = (new UserMapper()).Map(initial);
     //Assert
     Assert.AreEqual(expected.Email, actual.Email);
     Assert.AreEqual(expected.Name, actual.Name);
     Assert.AreEqual(expected.Password, actual.Password);
 }
 public void FromUserToUserLoginApi_FieldsAreEqual()
 {
     //Arrange
     var initial = new User
     {
         Id = 1,
         Email = "*****@*****.**",
         Name = "Roman",
         Password = "******"
     };
     var expected = new LoggedUserModel
     {
         EMail = "*****@*****.**",
         Name = "Roman",
         Id = 1
     };
     //Act
     var actual = (new UserLoginMapper()).FromUserToUserLoginApi(initial);
     //Assert
     Assert.AreEqual(expected.EMail, actual.EMail);
     Assert.AreEqual(expected.Name, actual.Name);
     Assert.AreEqual(expected.Id, actual.Id);
 }
        [Test] //+
        public void EditUserNameIsFalse_Test()
        {
            //Arrange
            User user = new User();
            user.Name = "Petro";
            user.Id = 1;
            user = null;

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(It.IsAny<int>())).Returns(user);
            worldOfWordsUow.Setup(t => t.Save()).Verifiable("All is fine");

            //Act
            var result = usServ.EditUserName("Andrew", 2);

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Exactly(1));
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Exactly(1));
            userReposit.Verify(t => t.GetById(It.IsAny<int>()), Times.Exactly(1));
            worldOfWordsUow.Verify(t => t.Save(), Times.Never);
            Assert.IsNull(user);
            Assert.IsFalse(result);
        }
        [Test]//work +
        public void CheckUserEmailIsFalse_Test()
        {
            //Arrange
            User user = new User();
            user.Name = "Petro";
            user.Id = 1;
            user.Email = "*****@*****.**";


            var forgotPassword = new ForgotPasswordUserModel();
            forgotPassword.Id = "5";
            forgotPassword.Email = "*****@*****.**";

            entity.Id = 5;

            var reposit = new Mock<IRepository<IncomingUser>>();
            var iusReposit = new Mock<IUserRepository>();

            IQueryable<User> Users = new List<User>
            {
                user
            }.AsQueryable<User>();


            worldOfWordsUow.Setup(t => t.UserRepository).Returns(iusReposit.Object);
            iusReposit.Setup(t => t.GetAll()).Returns(Users);

            //Act
            var result = usServ.CheckUserEmail(forgotPassword);

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Exactly(1));
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Exactly(1));
            iusReposit.Verify(t => t.GetAll(), Times.Exactly(1));
            Assert.IsFalse(result);
        }
        [Test] //+
        public void GetAmountOfUsersByRoleIdNotZero_Test()
        {
            //Arrange
            Role admin = new Role();
            admin.Id = 1;

            IQueryable<Role> rol = new List<Role>()
            {
                admin
            }.AsQueryable<Role>();

            User user = new User { Id = 5, Name = "Andrew" };
            var user_2 = new User();
            user_2.Id = 3;
            user.Roles = new List<Role>() { admin };
            user_2.Roles = new List<Role>() { admin };

            IQueryable<User> listOfUsers = new List<User>
           {
            user,
            user_2
           }.AsQueryable<User>();

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(listOfUsers);

            //Act
            int result = usServ.GetAmountOfUsersByRoleId(1);

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.AtLeastOnce());
            userReposit.Verify(t => t.GetAll(), Times.AtLeastOnce());

            Assert.IsTrue(result == 2);
        }
        [Test] //+
        public void SearchByNameAndRole_RoleIsZero_Test()
        {
            IRepository<WorldOfWords.Domain.Models.Role> RoleReposit = new Mock<IRepository<WorldOfWords.Domain.Models.Role>>().Object;

            #region user and role
            User user = new User();
            user.Name = "Andrew";
            user.Email = "*****@*****.**";
            user.Id = 2;

            Role admin = new Role();
            admin.Id = 0;

            user.Roles = new List<Role>() { admin };

            IQueryable<User> users = new List<User>()
            {
                user
            }.AsQueryable<User>();
            #endregion

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(users);

            //Act
            var userColl = usServ.SearchByNameAndRole("Andrew");

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetAll(), Times.Once);
            Assert.IsNotNull(userColl);
        }
        [Test] //Work +
        public void ChangePassword_Test()
        {
            //Arrange
            //PasswordHasher pasHesh = new PasswordHasher();
            //string password = pasHesh.HashPassword("hjkol68");
            ForgotPasswordUserModel model = new ForgotPasswordUserModel { Id = "5", Password = "******" };
            User user = new User();
            user.Email = "*****@*****.**";
            user.Id = 5;
            user.Password = "******";
            IQueryable<User> users = new List<User>()
            {
                user
            }.AsQueryable<User>();

            uowFactory.Setup(t => t.GetUnitOfWork()).Returns(worldOfWordsUow.Object);
            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(users);

            //Act
            usServ.ChangePassword(model);

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetAll(), Times.Once);
            Assert.AreNotEqual(model.Password, user.Password);
            Assert.AreEqual(user.Id.ToString(), model.Id);
        }
        [Test] //work - 100% +
        public void ChangeRolesOfUser_Test()
        {
            ///Arrange
            Mock<IRepository<WorldOfWords.Domain.Models.Role>> roleRepository = new Mock<IRepository<Role>>();

            Role admin = new Role();
            admin.Id = 1;

            IQueryable<Role> rol = new List<Role>()
            {
                admin
            }.AsQueryable<Role>();

            User user_2 = new User()
            {
                Email = "*****@*****.**",
                Id = 1,
                Roles = new List<Role> 
                { 
                    new Role
                    {
                        Id = 1
                    }
                }
            };

            IQueryable<User> users = new List<User>()
            {
                new User
                {
                Email = "*****@*****.**",
                Id = 1,
                Roles = new List<Role> 
                { 
                    new Role
                    {
                        Id = 1
                    }
                }}
            }.AsQueryable<User>();

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(users);
            worldOfWordsUow.Setup(t => t.RoleRepository).Returns(roleRepository.Object);
            roleRepository.Setup(t => t.GetAll()).Returns(rol);

            worldOfWordsUow.Setup(t => t.Save()).Verifiable();

            //Act
            var actual = usServ.ChangeRolesOfUser(user_2);

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetAll(), Times.Once);
            worldOfWordsUow.Verify(t => t.RoleRepository, Times.Once);
            roleRepository.Verify(t => t.GetAll(), Times.Once);
            worldOfWordsUow.VerifyAll();
            Assert.IsTrue(actual);
        }
        [Test] //+
        public void CheckUserIdIsFalse_Test()
        {
            //Assert
            User user = new User { Email = "*****@*****.**", Id = 15689 };
            ForgotPasswordUserModel checkEmail = new ForgotPasswordUserModel() { Id = user.Id.ToString(), Email = "*****@*****.**" };

            IQueryable<User> users = new List<User>()
            {
                user
            }.AsQueryable<User>();

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(users);
            tokenVaidation.Setup(t => t.GetHashSha256(It.IsAny<string>())).Returns("Hrin");

            //Act
            var result = usServ.CheckUserId(checkEmail);

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetAll(), Times.Once);
            tokenVaidation.Verify(t => t.GetHashSha256(user.Id.ToString()), Times.Once);
            Assert.IsFalse(result);
        }
        [Test] //work + 
        public void EditUserPasswordIsTrue_Test()
        {
            User user = new User();
            user.Email = "*****@*****.**";
            user.Id = 1;
            user.Password = "******";

            IQueryable<User> users = new List<User>()
            {
                user
            }.AsQueryable<User>();

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(It.IsAny<int>())).Returns(user);
            worldOfWordsUow.Setup(t => t.Save()).Verifiable("Saved");

            //Act
            var result = usServ.EditUserPassword("hello", 1);

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Exactly(1));
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Exactly(1));
            userReposit.Verify(t => t.GetById(It.IsAny<int>()), Times.Exactly(1));
            worldOfWordsUow.VerifyAll();
            Assert.IsTrue(result);
        }
        [Test] //work +
        public void EditUserPasswordIsFalse_Test()
        {
            User user = new User();
            user.Email = "*****@*****.**";
            user.Id = 1;
            user.Password = "******";

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(1)).Returns(user);
            worldOfWordsUow.Setup(t => t.Save()).Verifiable("Saved");

            //Act
            var result = usServ.EditUserPassword("bye258456", 0);

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Exactly(1));
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Exactly(1));
            userReposit.Verify(t => t.GetById(0), Times.Exactly(1));
            Assert.IsFalse(result);

        }
        [Test] //
        public void ConfirmUserRegistration_IsFalseTest()
        {
            //Arrange
            IncomingUser inUser = new IncomingUser
            {
                Email = "*****@*****.**",
                Id = 1,
                Password = "******",
                Name = "Stepan",
                Token = "jsdjsjd"
            };

            IQueryable<IncomingUser> incomUsers = new List<IncomingUser>
                {
                    inUser
                }.AsQueryable<IncomingUser>();

            User user = new User
            {
                Email = "*****@*****.**",
                Id = 1,
                Password = "******",
                Name = "Stepan",
                HashedToken = "sknsdmsopp"
            };

            IQueryable<Role> roles = new List<Role>
                {
                    new Role(){ Id = 1, Name = "Student"}
                }.AsQueryable<Role>();

            worldOfWordsUow.Setup(t => t.IncomingUserRepository).Returns(incUserReposit.Object);
            incUserReposit.Setup(t => t.GetAll()).Returns(incomUsers);
            incUserReposit.Setup(s => s.Delete(It.IsAny<IncomingUser>())).Verifiable("deleted");

            incUserMapper.Setup(t => t.ToDomainModel(It.IsAny<IncomingUser>())).Returns(user);
            worldOfWordsUow.Setup(t => t.RoleRepository).Returns(roleRepository.Object);
            roleRepository.Setup(t => t.GetAll()).Returns(roles);
            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.Add(user)).Verifiable("Added user");
            worldOfWordsUow.Setup(t => t.Save()).Verifiable("Saved");

            //Act
            var result = usServ.ConfirmUserRegistration(2, "jaflkasjdl");

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.IncomingUserRepository, Times.Once);
            incUserReposit.Verify(t => t.GetAll(), Times.Once);
            incUserReposit.Verify(t => t.Delete(It.IsAny<IncomingUser>()), Times.Never);
            incUserMapper.Verify(t => t.ToDomainModel(It.IsAny<IncomingUser>()), Times.Never);
            worldOfWordsUow.Verify(t => t.RoleRepository, Times.Never);
            roleRepository.Verify(t => t.GetAll(), Times.Never);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Never);
            userReposit.Verify(t => t.Add(It.IsAny<User>()), Times.Never);
            worldOfWordsUow.Verify(t => t.Save(), Times.Never);

            Assert.IsFalse(result);
        }
        [Test] //Work +
        public void GetUserNameIsNull_Test()
        {
            User user = new User();
            user.Name = "Andrew";
            user.Id = 5;

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(5)).Returns(user);

            var result = usServ.GetUserName(0);
            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(f => f.UserRepository, Times.Once);
            userReposit.Verify(w => w.GetById(5), Times.Never);
            userReposit.Verify(w => w.GetById(0), Times.Once);
            Assert.IsNull(result);
        }
        [Test] //Work
        public void ExistUser_Test()
        {
            //Arrange
            User user = new User();
            user.Email = entity.Email;
            IQueryable<User> Users = new List<User>
            {
                user
            }.AsQueryable();

            IQueryable<IncomingUser> incUsers = new List<IncomingUser>
            {
                entity
            }.AsQueryable<IncomingUser>();

            worldOfWordsUow.Setup(t => t.IncomingUserRepository).Returns(incUserReposit.Object);
            incUserReposit.Setup(t => t.GetAll()).Returns(incUsers);

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(Users);

            //Act
            var result = usServ.Exists(entity);

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Exactly(1));
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Exactly(1));
            userReposit.Verify(t => t.GetAll(), Times.Exactly(1));

            worldOfWordsUow.Verify(t => t.IncomingUserRepository, Times.Exactly(0));
            incUserReposit.Verify(t => t.GetAll(), Times.Exactly(0));

            Assert.AreEqual(Users.First().Email, entity.Email);
            Assert.IsTrue(result, "Variable is exist");
        }
        [Test] //+
        public void CheckUserAuthorization_IsTrue_Test()
        {
            //Arrange
            UserWithPasswordModel userLoginApi = new UserWithPasswordModel();
            PasswordHasher passHesher = new PasswordHasher();

            User user = new User();
            user.Email = entity.Email;
            user.Id = 4;
            user.Roles = new List<Role> { new Role() { Name = "admin", Id = user.Id } };

            userLoginApi.Password = "******";
            userLoginApi.Email = user.Email;
            string userPassword = passHesher.HashPassword(userLoginApi.Password);
            user.Password = userPassword;

            IQueryable<User> Users = new List<User>
            {
                user
            }.AsQueryable<User>();

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetAll()).Returns(Users);
            userReposit.Setup(t => t.AddOrUpdate(It.IsAny<User>())).Verifiable("added or updated");
            worldOfWordsUow.Setup(t => t.Save()).Verifiable("Saved");

            //Act
            var result = usServ.CheckUserAuthorization(userLoginApi);

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Exactly(2));
            userReposit.Verify(t => t.AddOrUpdate(It.IsAny<User>()), Times.Once);
            worldOfWordsUow.VerifyAll();
            Assert.IsTrue(result);
        }
        [Test] //+
        public void CheckUserNameIsTrue_Test()
        {
            //Arrange
            User user = new User();
            user.Name = "Petro";
            user.Id = 1;

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(It.IsAny<int>())).Returns(user);

            //Act
            var result = usServ.CheckUserName("Petro", 1);

            //Assert
            uowFactory.Verify(t => t.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetById(It.IsAny<int>()), Times.Once);
            Assert.IsTrue(result, "User is not Exist");
        }
예제 #22
0
 public bool ChangeRolesOfUser(User user)
 {
     using (var uow = _unitOfWorkFactory.GetUnitOfWork())
     {
         User userToChange = uow.UserRepository.GetAll().Include("Roles").FirstOrDefault(item => item.Id == user.Id);
         userToChange.Roles = new List<Role>();
         var queryOfNeededIds = user.Roles.Select(item => item.Id);
         var toAdd = uow.RoleRepository.GetAll().Where(item => queryOfNeededIds.Contains(item.Id)).ToList();
         foreach (var a in toAdd)
         {
             userToChange.Roles.Add(a);
         }
         uow.Save();
     }
     return true;
 }
        [Test] //+
        public void CheckUserNameIsFalse_NamesAreNotEqual_Test()
        {
            //Arrange
            User user = new User();
            user.Name = "Andrew";
            user.Id = 1;

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(It.IsAny<int>())).Returns(user);

            //Act
            var result = usServ.CheckUserName("Petro", 1);

            //Assert
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetById(It.IsAny<int>()), Times.Once);
            Assert.AreNotEqual(user.Name, "Petro");
            Assert.IsFalse(result, "User is not Exist");
        }
        [Test] //+
        public void CheckUserPasswordPasswordNotEqual_Test()
        {
            //Arrange
            PasswordHasher passHesh = new PasswordHasher();
            string passsword = passHesh.HashPassword("1235sjkf");

            User user = new User();
            user.Name = "Stepan";
            user.Id = 3;
            user.Password = passsword;

            worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
            userReposit.Setup(t => t.GetById(It.IsAny<int>())).Returns(user);

            //Act
            var result = usServ.CheckUserPassword("1ah45k7", user.Id);

            //Assert
            uowFactory.Verify(f => f.GetUnitOfWork(), Times.Once);
            worldOfWordsUow.Verify(t => t.UserRepository, Times.Once);
            userReposit.Verify(t => t.GetById(It.IsAny<int>()), Times.Once);
            Assert.IsFalse(result);
        }
        public void GetUsersNotBelongingToGroupTestPositive()
        {
            // Arrange

            // The group, not belonging to it users must be returned by test method
            var group = new Group
            {
                Id = 111,
                Course = new Course { Id = 222 },
                OwnerId = 333,
                CourseId = 222
            };

            var role1 = new Role { Name = "Student" };
            var role2 = new Role { Name = "AnotherRole" };

            // On the exit must be this user with this enrollment 

            // Enrollment to return
            var enrollment = new Enrollment
            {
                GroupId = 100,
                Group = new Group { Course = new Course { Id = 100 } }
            };

            // User to return
            var user = new User
            {
                Id = 100,
                Roles = new List<Role> { role1 },
                Enrollments = new List<Enrollment> { enrollment }
            };

            enrollment.User = user;

            // User to test "u.Id != group.OwnerId" condition in Service
            var user1 = new User
            {
                Id = 333,
                Roles = new List<Role> { role1 },
                Enrollments = new List<Enrollment> { enrollment }
            };

            // User to test "u.Enrollments.Select(e => e.Group.Course).FirstOrDefault(c => c.Id == course.Id) == null"
            // condition in Service
            var enrollment2 = new Enrollment
            {
                GroupId = 100,
                Group = new Group { Course = new Course { Id = 222 } }
            };
            var user2 = new User
            {
                Id = 333,
                Roles = new List<Role> { role1 },
                Enrollments = new List<Enrollment> { enrollment2 }
            };

            // User to test "!usersCurrentlyInGroup.Any(u2 => u2.Id == u.Id)" condition
            var user3 = new User
            {
                Id = 333,
                Roles = new List<Role> { role1 },
                Enrollments = new List<Enrollment> { enrollment2 }
            };

            // User to test "u.Roles.Select(r => r.Name).Contains("Student")" condition
            var user4 = new User
            {
                Id = 333,
                Roles = new List<Role> { role2 },
                Enrollments = new List<Enrollment> { enrollment2 }
            };

            // For enrollmentRepository to return
            var enrollments = new List<Enrollment>(new Enrollment[] {
                enrollment,
                new Enrollment { GroupId = 111, User = user1}
            }).AsQueryable();

            var users = (new List<User> { user, user1, user2, user3, user4 }).AsQueryable();

            var groupRepository = new Mock<IRepository<Group>>();
            unitOfWork.Setup(x => x.GroupRepository).Returns(groupRepository.Object);
            groupRepository.Setup(x => x.GetById(group.Id)).Returns(group);
            enrollmentRepository.Setup(x => x.GetAll()).Returns(enrollments);

            var userRepository = new Mock<IUserRepository>();
            unitOfWork.Setup(x => x.UserRepository).Returns(userRepository.Object);
            userRepository.Setup(x => x.GetAll()).Returns(users);

            // Act
            var result = enrollmentService.GetUsersNotBelongingToGroup(group.Id);

            // Assert
            Assert.IsTrue(result.TrueForAll(u => u.Roles.Select(r => r.Name).Contains("Student")),
                "User should have the Student role");
            Assert.IsTrue(result.TrueForAll(u => !u.Enrollments.Any( e => e.GroupId == group.Id)),
                "User shouldn't be in that group");
            Assert.IsTrue(result.TrueForAll(u => !u.Enrollments.Any(e => e.Group.CourseId == group.CourseId)),
                "User shouldn't be in the course that contains given group");
            Assert.IsTrue(result.TrueForAll(u => u.Id != group.OwnerId));
        }