public void Delete_Group_ReturnsBadRequestResult_Negative()
        {
            int groupId = 1;
            List<Enrollment> initialEnrollments = new List<Enrollment>
            {
                new Enrollment
                {
                    Id = 1,
                    GroupId = groupId,
                    UserId = 1,
                    Date = DateTime.Now
                },
                new Enrollment
                {
                    Id = 2,
                    GroupId = groupId,
                    UserId = 2,
                    Date = DateTime.Now
                },
                new Enrollment
                {
                    Id = 3,
                    GroupId = groupId,
                    UserId = 3,
                    Date = DateTime.Now
                }
            };

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            enrollmentService.Setup(x => x.GetByGroupId(groupId)).Returns(initialEnrollments);
            wordProgressService.Setup(x => x.RemoveProgressesForEnrollment(
                It.Is<int>(id => initialEnrollments.FirstOrDefault(e => e.Id == id) != null))).Returns(true);
            wordsuiteService.Setup(x => x.RemoveWordSuitesForEnrollment(
                It.Is<int>(id => initialEnrollments.FirstOrDefault(e => e.Id == id) != null))).Returns(true);
            groupService.Setup(x => x.DeleteById(groupId)).Returns(false);

            var actual = groupController.Delete(groupId);

            Assert.IsInstanceOf(typeof(BadRequestErrorMessageResult), actual);
        }
        public void Setup()
        {
            GenerateData("1", new[] { "NoRoles" });
            _groupForListingMapper = new Mock<IGroupForListingMapper>();
            _groupService = new Mock<IGroupService>();
            _enrollmentService = new Mock<IEnrollmentService>();
            _wordProgressService = new Mock<IWordProgressService>();
            _wordsuiteService = new Mock<IWordSuiteService>();
            _courseService = new Mock<ICourseService>();
            _courseMapper = new Mock<ICourseForGroupMapper>();
            _groupMapper = new Mock<IGroupMapper>();

            _controller = new GroupController(_groupService.Object, _groupForListingMapper.Object,
                _enrollmentService.Object, _wordProgressService.Object, _wordsuiteService.Object, _courseService.Object,
                _courseMapper.Object, _groupMapper.Object);
        }
        public void Post_NewGroup_ThrownException_Negative()
        {
            GroupModel initial = null;

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            Assert.Throws<ArgumentNullException>(() => groupController.Post(initial));
        }
        public void Post_NewGroup_ReturnsOkResult_Positive()
        {
            var initial = new GroupModel
            {
                Name = "Some Group Name",
                OwnerId = 1,
                CourseId = 1
            };

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            groupService.Setup(x => x.CheckIfGroupNameExists(initial)).Returns(false);
            groupService.Setup(x => x.Add(initial)).Returns(true);

            var actual = groupController.Post(initial);

            Assert.IsInstanceOf(typeof(OkResult), actual);
        }
        public void Get_Groups_ReturnsGroupsList_Positive()
        {
            var initial = new List<Group>
            {
                new Group
                {
                    Id=1,
                    CourseId=1,
                    OwnerId=1,
                    Name="Basic English",
                    Course = new Course
                    {
                        Name = "English.A1"
                    }
                },
                new Group
                {
                    Id=2,
                    CourseId=2,
                    OwnerId=1,
                    Name="Basic German",
                    Course = new Course
                    {
                        Name = "German.A1"
                    }
                },
                new Group
                {
                    Id=3,
                    CourseId=3,
                    OwnerId=1,
                    Name="Basic French",
                    Course = new Course
                    {
                        Name = "French.A1"
                    }
                }
            };
            var expected = new List<GroupForListingModel>
            {
                new GroupForListingModel
                {
                    Id=1,
                    CourseId=1,
                    Name="Basic English",
                    CourseName = "English.A1"
                },
                new GroupForListingModel
                {
                    Id=2,
                    CourseId=2,
                    Name="Basic German",
                    CourseName="German.A1"
                },
                new GroupForListingModel
                {
                    Id=3,
                    CourseId=3,
                    Name="Basic French",
                    CourseName="French.A1"
                }
            };

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();
            int userId = 1;

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            groupService.Setup(x => x.GetAll(userId)).Returns(initial);
            groupForListingMapper.Setup(x => x.MapToGroupModelCollection(initial)).Returns(expected);

            var actual = groupController.Get();

            CollectionAssert.AreEqual(expected, actual);
        }
        public void Get_GetGroupById_ReturnsNull_Negative()
        {
            Group expected = null;
            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            int userId = 1;
            int groupId = 111111;

            groupService.Setup(x => x.GetById(groupId, userId)).Returns(expected);

            var actual = groupController.Get(groupId);

            Assert.AreEqual(expected, actual);
        }
        public void Get_GetGroupById_ReturnsGroupModel_Positive()
        {
            var initial = new Group
            {
                Id = 1,
                OwnerId = 1,
                CourseId = 1,
                Name = "Simple English",
                Course = new Course
                {
                    Name = "English.A1"
                }
            };

            var expected = new GroupForListingModel
            {
                Id = 1,
                CourseId = 1,
                Name = "Simple English",
                CourseName = "English.A1"
            };

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            int groupId = 1;
            int userId = 1;

            groupService.Setup(x => x.GetById(groupId, userId)).Returns(initial);
            groupForListingMapper.Setup(x => x.MapToGroupModel(initial)).Returns(expected);

            var actual = groupController.Get(groupId);

            Assert.AreEqual(expected, actual);
        }
        public void Get_GetCourses_ReturnsCourses_Positive()
        {
            var initial = new List<Course>
            {
                new Course
                {
                    Id = 1,
                    Name = "English.A1",
                    LanguageId = 1,
                    OwnerId = 1,
                    IsPrivate = false
                },
                new Course
                {
                    Id = 2,
                    Name = "French.A1",
                    LanguageId = 2,
                    OwnerId = 1,
                    IsPrivate = false
                }
            };

            var expected = new List<CourseForGroupModel>
            {
                new CourseForGroupModel
                {
                    Id = 1,
                    Name = "English.A1"
                },
                new CourseForGroupModel
                {
                    Id = 2,
                    Name = "French.A1"
                }
            };

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            int userId = 1;

            courseService.Setup(x => x.GetAllCourses(userId)).Returns(initial);
            courseMapper.Setup(x => x.MapToCourseModelCollection(initial)).Returns(expected);

            var actual = groupController.GetCourses();

            CollectionAssert.AreEqual(expected, actual);
        }