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);
}
