public void EnrollmentInsertDeletePostTest() { try { var enrollmentController = new EnrollmentController(); enrollmentController.DeleteEnrollment("A000005", 105); var enrollment = enrollmentController.GetEnrollmentInfo("A000005", 105); Assert.AreEqual(null, enrollment); enrollmentController.InsertEnrollment(new Enrollment { StudentId = "A000005", ScheduleId = 105, Grade = "D+" }); enrollment = enrollmentController.GetEnrollmentInfo("A000005", 105); Assert.AreEqual("A000005", enrollment[0].StudentId); Assert.AreEqual(105, enrollment[0].ScheduleId); Assert.AreEqual("D+", enrollment[0].Grade); enrollmentController.DeleteEnrollment("A000005", 105); enrollment = enrollmentController.GetEnrollmentInfo("A000005", 105); Assert.AreEqual(null, enrollment); } catch { throw; } }
public void EnrollmentGetTest() { var enrollmentController = new EnrollmentController(); var enrollment = enrollmentController.GetEnrollmentInfo("A000001", 101); Assert.AreEqual("A000001", enrollment[0].StudentId); Assert.AreEqual(101, enrollment[0].ScheduleId); Assert.AreEqual("C", enrollment[0].Grade); }
public async Task GetDesignationWiseVolunteersByYear_WhenYearsIsZero_ShouldReturnBadRequest() { //Arrange var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetDesignationWiseVolunteersByYear(0); //Assert Assert.IsType <BadRequestResult>(response); }
public async Task Post_WhenSaveEmptyEnrollments_ShouldReturnBadRequest() { //Arrange var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.Post(null); //Assert Assert.IsType <BadRequestResult>(response); }
public async Task GetTopFrequentVolunteers_WhenParameterIsZero_ShouldReturnBadRequest() { //Arrange var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetTopFrequentVolunteers(0); //Assert Assert.IsType <BadRequestResult>(response); }
public async Task GetEnrollmentsByFilterId_WhenFilterIdIsZero_ShouldReturnBadRequest() { //Arrange var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetEnrollmentsByFilterId(0); //Assert Assert.IsType <BadRequestResult>(response); }
public void Setup() { GenerateData("1", new[] { "NoRoles" }); _enrollmentMapper = new Mock <IEnrollmentMapper>(); _courseService = new Mock <ICourseService>(); _enrollmentService = new Mock <IEnrollmentService>(); _wordSuiteService = new Mock <IWordSuiteService>(); _wordProgressService = new Mock <IWordProgressService>(); _groupService = new Mock <IGroupService>(); _userMapper = new Mock <IUserForListingMapper>(); _controller = new EnrollmentController(_enrollmentService.Object, _enrollmentMapper.Object, _wordSuiteService.Object, _wordProgressService.Object, _userMapper.Object, _courseService.Object, _groupService.Object); }
public async Task GetAllNewVolunteers_WhenYearsIsNotZero_ShouldReturnDesignationWiseVolunteersByYear() { //Arrange _enrollmentProcessorMock.Setup(p => p.GetAllNewVolunteers(null)).ReturnsAsync(_enrollments); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetAllNewVolunteers(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Enrollment> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task Post_WhenSaveValidEnrollments_ShouldReturnSaveSuccessTrue() { //Arrange _enrollmentProcessorMock.Setup(p => p.SaveEnrollments(_enrollments)).ReturnsAsync(true); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.Post(_enrollments); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <Boolean>(okResult.Value); Assert.True(returnValue); }
public async Task GetUniqueVolunteersByDate_WhenEnrollmentsMatchedWithGivenParameters_ShouldReturnFilteredEnrollments() { //Arrange _enrollmentProcessorMock.Setup(p => p.GetUniqueVolunteersByDate("01/01/2019", "01/01/2019", null)).ReturnsAsync(_enrollments); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetUniqueVolunteersByDate("01/01/2019", "01/01/2019"); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Enrollment> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetEnrollmentsByFilterId_WhenFilterIdIsValid_ShouldReturnEnrollmentsByFilterId() { //Arrange _enrollmentProcessorMock.Setup(p => p.GetEnrollmentsByFilterId(1)).ReturnsAsync(_enrollments); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetEnrollmentsByFilterId(1); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Enrollment> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetEnrolledAssociates_WhenEnrollmentsExist_ShouldReturnAllEnrollments() { //Arrange _enrollmentProcessorMock.Setup(p => p.GetEnrolledAssociates(null)).ReturnsAsync(_enrollments); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetEnrolledAssociates(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Enrollment> >(okResult.Value); Assert.NotEmpty(returnValue); }
public void Post_EnrollUsersToGroup_ThrowsArgumentNullException_Negative() { GenerateData("1", new[] { "NoRoles" }); Mock <IEnrollmentMapper> enrollmentMapper = new Mock <IEnrollmentMapper>(); Mock <ICourseService> courseService = new Mock <ICourseService>(); Mock <IEnrollmentService> enrollmentService = new Mock <IEnrollmentService>(); Mock <IWordSuiteService> wordSuiteService = new Mock <IWordSuiteService>(); Mock <IWordProgressService> wordProgressService = new Mock <IWordProgressService>(); Mock <IGroupService> groupService = new Mock <IGroupService>(); Mock <IUserForListingMapper> userMapper = new Mock <IUserForListingMapper>(); EnrollmentController controller = new EnrollmentController(enrollmentService.Object, enrollmentMapper.Object, wordSuiteService.Object, wordProgressService.Object, userMapper.Object, courseService.Object, groupService.Object); Assert.Throws <ArgumentNullException>(() => controller.EnrollUsersToGroup(null)); }
public async Task GetEnrollmentsByFilter_WhenPassValidFilters_ShouldReturnFilteredEnrollments() { //Arrange var filter = new ReportFilter(); _enrollmentProcessorMock.Setup(p => p.GetEnrollmentsByFilter(null, filter)).ReturnsAsync(_enrollments); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetEnrollmentsByFilter(filter); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Enrollment> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetDesignationWiseVolunteersCount_WhenEnrollmentsExist_ShouldReturnDesignationWiseVolunteersCount() { //Arrange var dict = new Dictionary <string, int>(); dict.Add("key", 15); _enrollmentProcessorMock.Setup(p => p.GetDesignationWiseVolunteersCount(null)).ReturnsAsync(dict); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetDesignationWiseVolunteersCount(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <Dictionary <string, int> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task Get_WhenEnrollmentsExist_ShouldReturnAllEnrollments() { //Arrange Dictionary <string, string> dict = new Dictionary <string, string>(); dict.Add("UserId", "123456"); dict.Add("role", "Admin"); _enrollmentProcessorMock.Setup(p => p.GetAll(null)).ReturnsAsync(_enrollments); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetAsync(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Enrollment> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetBaseLocations_WhenBaseLocationsExist_ShouldReturnAllBaseLocations() { //Arrange var baseLocations = new List <string> { "bl1", "bl2" }; _enrollmentProcessorMock.Setup(p => p.GetBaseLocations()).ReturnsAsync(baseLocations); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetBaseLocations(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <string> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetTopFrequentVolunteers_WhenEnrollmentsMatchedWithGivenParameters_ShouldReturnFilteredEnrollments() { //Arrange var _associates = new List <Associate> { new Associate(), new Associate() }; _enrollmentProcessorMock.Setup(p => p.GetTopFrequentVolunteers(10, null)).ReturnsAsync(_associates); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetTopFrequentVolunteers(10); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Associate> >(okResult.Value); Assert.NotEmpty(returnValue); }
public void EnrollmentUpdatePostTest() { try { var enrollmentController = new EnrollmentController(); var enrollment = enrollmentController.GetEnrollmentInfo("A000002", 102); Assert.AreEqual("A000002", enrollment[0].StudentId); Assert.AreEqual(102, enrollment[0].ScheduleId); Assert.AreEqual("A", enrollment[0].Grade); enrollmentController.UpdateEnrollment(new Enrollment { StudentId = "A000002", ScheduleId = 102, Grade = "B-" }); enrollment = enrollmentController.GetEnrollmentInfo("A000002", 102); Assert.AreEqual("A000002", enrollment[0].StudentId); Assert.AreEqual(102, enrollment[0].ScheduleId); Assert.AreEqual("B-", enrollment[0].Grade); enrollmentController.UpdateEnrollment(new Enrollment { StudentId = "A000002", ScheduleId = 102, Grade = "A" }); enrollment = enrollmentController.GetEnrollmentInfo("A000002", 102); Assert.AreEqual("A000002", enrollment[0].StudentId); Assert.AreEqual(102, enrollment[0].ScheduleId); Assert.AreEqual("A", enrollment[0].Grade); } catch { throw; } }
public async Task GetDesignationWiseVolunteersByYear_WhenYearsIsNotZero_ShouldReturnDesignationWiseVolunteersByYear() { //Arrange var lst = new List <NewRepeatedVolunteersByYear> { new NewRepeatedVolunteersByYear(), new NewRepeatedVolunteersByYear() }; _enrollmentProcessorMock.Setup(p => p.GetDesignationWiseNewRepeatedVolunteersCountByYear(5, null)).ReturnsAsync(lst); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetDesignationWiseVolunteersByYear(5); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <NewRepeatedVolunteersByYear> >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetTopVolunteerData_WhenDataExist_ShouldReturnTopEnrollments() { //Arrange var dict = new Dictionary <string, List <decimal> >(); dict.Add("key1", new List <decimal> { 1, 2 }); _enrollmentProcessorMock.Setup(p => p.GetTopVolunteerData(null)).ReturnsAsync(dict); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetTopVolunteerData(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <Dictionary <string, List <decimal> > >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetDateWiseVolunteersCount_WhenYearsIsNotZero_ShouldReturnDesignationWiseVolunteersByYear() { //Arrange var dict = new Dictionary <DateTime, List <int> >(); dict.Add(new DateTime(), new List <int> { 15, 20 }); _enrollmentProcessorMock.Setup(p => p.GetDateWiseVolunteersCount(null)).ReturnsAsync(dict); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetDateWiseVolunteersCount(); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <Dictionary <DateTime, List <int> > >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetYearlyVolunteersCount_WhenValidYearsCountPassed_ShouldReturnEnrollmentsOnGivenYears() { //Arrange var dict = new Dictionary <int, List <int> >(); dict.Add(1, new List <int> { 1, 2 }); _enrollmentProcessorMock.Setup(p => p.GetYearlyVolunteersCount(5, null)).ReturnsAsync(dict); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetYearlyVolunteersCount(5); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <Dictionary <int, List <int> > >(okResult.Value); Assert.NotEmpty(returnValue); }
public async Task GetYearlyBuWiseVolunteersCount_WhenYearsIsNotZero_ShouldReturnEnrollmentsOnGivenYears() { //Arrange var dict = new Dictionary <string, int>(); dict.Add("key", 15); var dictList = new List <Dictionary <string, int> > { dict }; _enrollmentProcessorMock.Setup(p => p.GetYearlyBuWiseVolunteersCount(5, null)).ReturnsAsync(dictList); var controller = new EnrollmentController(_enrollmentProcessorMock.Object); //Act var response = await controller.GetYearlyBuWiseVolunteersCount(5); //Assert var okResult = Assert.IsType <OkObjectResult>(response); var returnValue = Assert.IsType <List <Dictionary <string, int> > >(okResult.Value); Assert.NotEmpty(returnValue); }
public void Delete_DeleteEntrollment_ReturnsBadRequestResult_Negative() { int enrollmentId = 1; GenerateData("1", new[] { "NoRoles" }); Mock <IEnrollmentMapper> enrollmentMapper = new Mock <IEnrollmentMapper>(); Mock <ICourseService> courseService = new Mock <ICourseService>(); Mock <IEnrollmentService> enrollmentService = new Mock <IEnrollmentService>(); Mock <IWordSuiteService> wordSuiteService = new Mock <IWordSuiteService>(); Mock <IWordProgressService> wordProgressService = new Mock <IWordProgressService>(); Mock <IGroupService> groupService = new Mock <IGroupService>(); Mock <IUserForListingMapper> userMapper = new Mock <IUserForListingMapper>(); EnrollmentController controller = new EnrollmentController(enrollmentService.Object, enrollmentMapper.Object, wordSuiteService.Object, wordProgressService.Object, userMapper.Object, courseService.Object, groupService.Object); wordProgressService.Setup(x => x.RemoveProgressesForEnrollment(enrollmentId)).Returns(true); wordSuiteService.Setup(x => x.RemoveWordSuitesForEnrollment(enrollmentId)).Returns(false); enrollmentService.Setup(x => x.DeleteById(enrollmentId)).Returns(true); var actual = controller.Delete(enrollmentId); Assert.IsInstanceOf(typeof(BadRequestErrorMessageResult), actual); }
public void Get_GetEnrollmentsByGroupId_ReturnsEnrollments_Positive() { int groupId = 1; int userId = 1; int courseId = 1; var initialEnrollments = new List <Enrollment> { new Enrollment { Id = 1, User = new User { Id = 1, Name = "Roman" }, GroupId = groupId, Date = DateTime.Now }, new Enrollment { Id = 2, User = new User { Id = 2, Name = "Andriy" }, GroupId = groupId, Date = DateTime.Now }, new Enrollment { Id = 3, User = new User { Id = 3, Name = "Nazar" }, GroupId = groupId, Date = DateTime.Now } }; var initialGroup = new Group { Id = groupId, OwnerId = userId, Name = "Basic English", CourseId = courseId }; var userProgressMapping = new Dictionary <int, double>(); userProgressMapping.Add(1, 68.53); userProgressMapping.Add(2, 76.56); userProgressMapping.Add(3, 28.43); var expected = new List <EnrollmentWithProgressModel>(); foreach (var enrollment in initialEnrollments) { expected.Add(new EnrollmentWithProgressModel() { Enrollment = new EnrollmentModel { Id = enrollment.Id, User = new UserForListingModel { Id = enrollment.User.Id, Name = enrollment.User.Name }, GroupId = enrollment.GroupId, Date = string.Format("{0:dd.MM.yyyy}", enrollment.Date) }, Progress = userProgressMapping[enrollment.User.Id] }); } initialEnrollments.Reverse(); GenerateData("1", new[] { "NoRoles" }); Mock <IEnrollmentMapper> enrollmentMapper = new Mock <IEnrollmentMapper>(); Mock <ICourseService> courseService = new Mock <ICourseService>(); Mock <IEnrollmentService> enrollmentService = new Mock <IEnrollmentService>(); Mock <IWordSuiteService> wordSuiteService = new Mock <IWordSuiteService>(); Mock <IWordProgressService> wordProgressService = new Mock <IWordProgressService>(); Mock <IGroupService> groupService = new Mock <IGroupService>(); Mock <IUserForListingMapper> userMapper = new Mock <IUserForListingMapper>(); EnrollmentController controller = new EnrollmentController(enrollmentService.Object, enrollmentMapper.Object, wordSuiteService.Object, wordProgressService.Object, userMapper.Object, courseService.Object, groupService.Object); enrollmentService.Setup(x => x.GetByGroupId(groupId)).Returns(initialEnrollments); enrollmentMapper.Setup(x => x.MapToEnrollmentModelCollection(initialEnrollments)).Returns( initialEnrollments.Select(e => new EnrollmentModel { Id = e.Id, GroupId = e.GroupId, User = new UserForListingModel { Id = e.User.Id, Name = e.User.Name }, Date = string.Format("{0:dd.MM.yyyy}", e.Date) }).ToList()); groupService.Setup(x => x.GetById(groupId, userId)).Returns(initialGroup); courseService.Setup(x => x.GetProgress(courseId, It.Is <int>(id => initialEnrollments.FirstOrDefault(e => e.User.Id == id) != null))) .Returns <int, int>((cId, uId) => userProgressMapping[uId]); var actual = controller.GetByGroupId(groupId); Assert.That(actual, Is.EquivalentTo(expected).Using(new EnrollmentWithProgressModelComparer())); }
public void Get_GetUsersNotBelongingToGroups_ReturnsUsers_Positive() { var initialUsers = new List <User> { new User { Id = 4, Name = "Sasha", Email = "*****@*****.**" }, new User { Id = 5, Name = "Slava", Email = "*****@*****.**" }, new User { Id = 6, Name = "Yaryna", Email = "*****@*****.**" }, new User { Id = 7, Name = "Yura", Email = "*****@*****.**" } }; var expected = new List <UserForListingModel> { new UserForListingModel { Id = 4, Name = "Sasha" }, new UserForListingModel { Id = 5, Name = "Slava" }, new UserForListingModel { Id = 6, Name = "Yaryna" }, new UserForListingModel { Id = 7, Name = "Yura" } }; int groupId = 1; GenerateData("1", new[] { "NoRoles" }); Mock <IEnrollmentMapper> enrollmentMapper = new Mock <IEnrollmentMapper>(); Mock <ICourseService> courseService = new Mock <ICourseService>(); Mock <IEnrollmentService> enrollmentService = new Mock <IEnrollmentService>(); Mock <IWordSuiteService> wordSuiteService = new Mock <IWordSuiteService>(); Mock <IWordProgressService> wordProgressService = new Mock <IWordProgressService>(); Mock <IGroupService> groupService = new Mock <IGroupService>(); Mock <IUserForListingMapper> userMapper = new Mock <IUserForListingMapper>(); EnrollmentController controller = new EnrollmentController(enrollmentService.Object, enrollmentMapper.Object, wordSuiteService.Object, wordProgressService.Object, userMapper.Object, courseService.Object, groupService.Object); enrollmentService.Setup(x => x.GetUsersNotBelongingToGroup(groupId)).Returns(initialUsers); userMapper.Setup(x => x.MapToUserModelCollection(initialUsers)).Returns(expected); var actual = controller.GetUsersNotBelongingToGroup(groupId); CollectionAssert.AreEqual(expected, actual); }
public void Post_EnrollUsersToGroup_ReturnsBadRequestResult_Negative() { var initialUsers = new List <UserForListingModel> { new UserForListingModel { Id = 4, Name = "Sasha" }, new UserForListingModel { Id = 5, Name = "Slava" }, new UserForListingModel { Id = 6, Name = "Yaryna" }, new UserForListingModel { Id = 7, Name = "Yura" } }; var mappedUsers = new List <User> { new User { Id = 4, Name = "Sasha" }, new User { Id = 5, Name = "Slava" }, new User { Id = 6, Name = "Yaryna" }, new User { Id = 7, Name = "Yura" } }; int groupId = 1; UsersForEnrollmentModel data = new UsersForEnrollmentModel { GroupId = groupId, UserModels = initialUsers }; GenerateData("1", new[] { "NoRoles" }); Mock <IEnrollmentMapper> enrollmentMapper = new Mock <IEnrollmentMapper>(); Mock <ICourseService> courseService = new Mock <ICourseService>(); Mock <IEnrollmentService> enrollmentService = new Mock <IEnrollmentService>(); Mock <IWordSuiteService> wordSuiteService = new Mock <IWordSuiteService>(); Mock <IWordProgressService> wordProgressService = new Mock <IWordProgressService>(); Mock <IGroupService> groupService = new Mock <IGroupService>(); Mock <IUserForListingMapper> userMapper = new Mock <IUserForListingMapper>(); EnrollmentController controller = new EnrollmentController(enrollmentService.Object, enrollmentMapper.Object, wordSuiteService.Object, wordProgressService.Object, userMapper.Object, courseService.Object, groupService.Object); userMapper.Setup(x => x.MapCollection(initialUsers)).Returns(mappedUsers); enrollmentService.Setup(x => x.EnrollUsersToGroup(mappedUsers, groupId)).Returns(true); wordSuiteService.Setup(x => x.CopyWordsuitesForUsersByGroup(mappedUsers, groupId)).Returns(true); wordProgressService.Setup(x => x.CopyProgressesForUsersInGroup(mappedUsers, groupId)).Returns(false); var actual = controller.EnrollUsersToGroup(data); Assert.IsInstanceOf(typeof(BadRequestErrorMessageResult), actual); }