public async Task AsyncWhenCreateALessonStudentWhenLessonIsNotFound()
{
var mockLessonStudentRepository = GetDefaultILessonStudentRepositoryInstance();
var mockLessonRepository = GetDefaultILessonRepositoryInstance();
var mockStudentRepository = GetDefaultIStudentRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
LessonStudent lessonStudent = new LessonStudent();
lessonStudent.StudentId = 104;
//STUDENT
Student student = new Student();
student.Id = 104;
lessonStudent.Student = student;
mockStudentRepository.Setup(r => r.FindById(student.Id))
.Returns(Task.FromResult <Student>(student));
mockLessonStudentRepository.Setup(r => r.FindById(lessonStudent.LessonId, lessonStudent.StudentId))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
mockLessonStudentRepository.Setup(r => r.AddAsync(lessonStudent))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
var service = new LessonStudentService(mockLessonStudentRepository.Object, mockUnitOfWork.Object, mockLessonRepository.Object, mockStudentRepository.Object);
LessonStudentResponse result = await service.SaveAsync(lessonStudent);
var message = result.Message;
message.Should().Be("Lesson not found");
}
public async Task AsyncWhenCreateALessonStudentGivenAnStudentThatIsAlreadyThere()
{
var mockLessonStudentRepository = GetDefaultILessonStudentRepositoryInstance();
var mockLessonRepository = GetDefaultILessonRepositoryInstance();
var mockStudentRepository = GetDefaultIStudentRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
//LESSON TYPE
LessonType lessonType = new LessonType();
lessonType.Id = 1;
lessonType.Lessons = new List <Lesson>();
lessonType.StudentsQuantity = 2;
//LESSON
Lesson lesson = new Lesson();
lesson.Id = 1;
lesson.Vacants = 2;
lesson.LessonType = lessonType;
lesson.LessonTypeId = lessonType.Id;
lessonType.Lessons.Add(lesson);
LessonStudent lessonStudent = new LessonStudent();
lessonStudent.LessonId = 1;
lessonStudent.StudentId = 104;
//STUDENT
Student student = new Student();
student.Id = 104;
lessonStudent.Lesson = lesson;
lessonStudent.Student = student;
mockStudentRepository.Setup(r => r.FindById(student.Id))
.Returns(Task.FromResult <Student>(student));
mockLessonRepository.Setup(r => r.FindById(lesson.Id))
.Returns(Task.FromResult <Lesson>(lesson));
mockLessonStudentRepository.Setup(r => r.FindById(lessonStudent.LessonId, lessonStudent.StudentId))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
mockLessonStudentRepository.Setup(r => r.AddAsync(lessonStudent))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
mockLessonStudentRepository.Setup(r => r.ExistsByLessonIdAndStudentId(lessonStudent.LessonId, lessonStudent.StudentId))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
var service = new LessonStudentService(mockLessonStudentRepository.Object, mockUnitOfWork.Object, mockLessonRepository.Object, mockStudentRepository.Object);
LessonStudentResponse result = await service.SaveAsync(lessonStudent);
var message = result.Message;
message.Should().Be("You are already part of this lesson");
}
public async Task AssignLessonStudent(int lessonId, int studentId, LessonStudent ls)
{
LessonStudent lessonStudent = await FindById(lessonId, studentId);
if (lessonStudent == null)
{
lessonStudent = ls;
await AddAsync(lessonStudent);
}
}
public async Task AsyncWhenCreateALessonStudentWhenStudentIsNotFound()
{
var mockLessonStudentRepository = GetDefaultILessonStudentRepositoryInstance();
var mockLessonRepository = GetDefaultILessonRepositoryInstance();
var mockStudentRepository = GetDefaultIStudentRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
//LESSON TYPE
LessonType lessonType = new LessonType();
lessonType.Id = 1;
lessonType.Lessons = new List <Lesson>();
lessonType.StudentsQuantity = 2;
//LESSON
Lesson lesson = new Lesson();
lesson.Id = 1;
lesson.Vacants = 2;
lesson.LessonType = lessonType;
lesson.LessonTypeId = lessonType.Id;
lessonType.Lessons.Add(lesson);
LessonStudent lessonStudent = new LessonStudent();
lessonStudent.LessonId = 1;
lessonStudent.StudentId = 104;
mockLessonRepository.Setup(r => r.FindById(lesson.Id))
.Returns(Task.FromResult <Lesson>(lesson));
mockLessonStudentRepository.Setup(r => r.FindById(lessonStudent.LessonId, lessonStudent.StudentId))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
mockLessonStudentRepository.Setup(r => r.AddAsync(lessonStudent))
.Returns(Task.FromResult <LessonStudent>(lessonStudent));
var service = new LessonStudentService(mockLessonStudentRepository.Object, mockUnitOfWork.Object, mockLessonRepository.Object, mockStudentRepository.Object);
LessonStudentResponse result = await service.SaveAsync(lessonStudent);
var message = result.Message;
message.Should().Be("Student not found");
}
public async Task WhenTheStudentSignsUpForTheSecondTimeForThisLesson()
{
_lessonStudent = new LessonStudent();
_lessonStudent.StudentId = _student.Id;
_lessonStudent.Student = _student;
_lessonStudent.LessonId = _lesson.Id;
_lessonStudent.Lesson = _lesson;
_lessonStudentRepository = new Mock <ILessonStudentRepository>();
_lessonStudentRepository.Setup(r => r.ExistsByLessonIdAndStudentId(_lessonStudent.LessonId, _lessonStudent.StudentId))
.Returns(Task.FromResult <LessonStudent>(_lessonStudent));
_lessonStudentService = new LessonStudentService(_lessonStudentRepository.Object, GetDefaultIUnitOfWorkInstance().Object,
_lessonRepository.Object, _studentRepository.Object);
_secondResponse = await _lessonStudentService.SaveAsync(_lessonStudent);
}
public async Task WhenTheStudentSignsUpForTheALessonThatIsFull()
{
_lessonStudent = new LessonStudent();
_lessonStudent.StudentId = _student.Id;
_lessonStudent.Student = _student;
_lessonStudent.LessonId = _lesson.Id;
_lessonStudent.Lesson = _lesson;
_lessonStudentRepository = new Mock <ILessonStudentRepository>();
_lesson.Contador = 2;
_lessonRepository = new Mock <ILessonRepository>();
_lessonRepository.Setup(r => r.FindById(_lesson.Id))
.Returns(Task.FromResult <Lesson>(_lesson));
_lessonStudentService = new LessonStudentService(_lessonStudentRepository.Object, GetDefaultIUnitOfWorkInstance().Object,
_lessonRepository.Object, _studentRepository.Object);
_thirdResponse = await _lessonStudentService.SaveAsync(_lessonStudent);
}
public async Task <LessonStudentResponse> SaveAsync(LessonStudent lessonStudent)
{
var existingLesson = await _lessonRepository.FindById(lessonStudent.LessonId);
if (existingLesson == null)
{
return(new LessonStudentResponse("Lesson not found"));
}
var existingStudent = await _studentRepository.FindById(lessonStudent.StudentId);
Console.WriteLine(existingLesson.LessonStudents.Count);
if (existingLesson.Contador == existingLesson.LessonType.StudentsQuantity)
{
return(new LessonStudentResponse("This lesson is full"));
}
if (existingStudent == null)
{
return(new LessonStudentResponse("Student not found"));
}
if (_lessonStudentRepository.ExistsByLessonIdAndStudentId(lessonStudent.LessonId, lessonStudent.StudentId).Result != null)
{
return(new LessonStudentResponse("You are already part of this lesson"));
}
try
{
await _lessonStudentRepository.AddAsync(lessonStudent);
await _unitOfWork.CompleteAsync();
return(new LessonStudentResponse(lessonStudent));
}
catch (Exception ex)
{
return(new LessonStudentResponse($"An error ocurred while saving the lessonStudent: {ex.Message}"));
}
}
public void GivenTheTutorWantsToSeeTheAverageScoreForACourseAndTypeOfCourse(int p0, int p1, int p2)
{
_lessonRepository = GetDefaultILessonRepositoryInstance();
List <Lesson> lessons = new List <Lesson>();
Lesson lesson = new Lesson();
lesson.Id = 1;
//Lesson lesson1 = new Lesson();
//lesson1.Id = 2;
//Lesson lesson2 = new Lesson();
//lesson2.Id = 3;
lessons.Add(lesson);
//lessons.Add(lesson1);
//lessons.Add(lesson2);
iLessons = lessons as IEnumerable <Lesson>;
_lessonRepository.Setup(r => r.ListByTutorIdAndCourseIdAndLessonTypeIdAsync(p0, p1, p2)).
Returns(Task.FromResult <IEnumerable <Lesson> >(iLessons));
List <LessonStudent> lessonStudents = new List <LessonStudent>();
LessonStudent lessonStudent = new LessonStudent();
lessonStudent.LessonId = lesson.Id;
lessonStudent.Qualification = 3;
LessonStudent lessonStudent1 = new LessonStudent();
lessonStudent.LessonId = lesson.Id;
lessonStudent1.Qualification = 5;
lessonStudents.Add(lessonStudent);
lessonStudents.Add(lessonStudent1);
iLessonStudents = lessonStudents as IEnumerable <LessonStudent>;
_lessonStudentRepository = GetDefaultILessonStudentRepositoryInstance();
_lessonStudentRepository.Setup(r => r.ListStudentsByLessonIdAsync(lesson.Id))
.Returns(Task.FromResult <IEnumerable <LessonStudent> >(iLessonStudents));
}
//Business rule #3
public async Task <LessonStudentResponse> SaveFeedbackAsync(int lessonId, int studentId, LessonStudent lessonStudent)
{
var existingLessonStudent = await _lessonStudentRepository.FindById(lessonId, studentId);
if (existingLessonStudent == null)
{
return(new LessonStudentResponse("LessonStudent not found"));
}
if (lessonStudent.Qualification == 0)
{
return(new LessonStudentResponse("It’s necessary to assign number of starts"));
}
existingLessonStudent.Qualification = lessonStudent.Qualification;
existingLessonStudent.Comment = lessonStudent.Comment;
if (lessonStudent.Complaint == true)
{
if (lessonStudent.Comment == "" || lessonStudent.Comment == "-")
{
return(new LessonStudentResponse("Write a comment"));
}
}
existingLessonStudent.Complaint = lessonStudent.Complaint;
try
{
_lessonStudentRepository.Update(existingLessonStudent);
await _unitOfWork.CompleteAsync();
return(new LessonStudentResponse(existingLessonStudent));
}
catch (Exception ex)
{
return(new LessonStudentResponse($"An error ocurred while updating the lessonStudent: {ex.Message}"));
}
}
public async Task <LessonStudentResponse> UpdateAsync(int lessonId, int studentId, LessonStudent lessonStudent)
{
var existingLessonStudent = await _lessonStudentRepository.FindById(lessonId, studentId);
if (existingLessonStudent == null)
{
return(new LessonStudentResponse("LessonStudent not found"));
}
existingLessonStudent.LessonId = lessonStudent.LessonId;
try
{
_lessonStudentRepository.Update(existingLessonStudent);
await _unitOfWork.CompleteAsync();
return(new LessonStudentResponse(existingLessonStudent));
}
catch (Exception ex)
{
return(new LessonStudentResponse($"An error ocurred while updating the lessonStudent: {ex.Message}"));
}
}
public async Task AddAsync(LessonStudent lessonStudent)
{
await _context.LessonStudents.AddAsync(lessonStudent);
}
public void Update(LessonStudent lessonStudent)
{
_context.LessonStudents.Update(lessonStudent);
}
public void Remove(LessonStudent lessonStudent)
{
_context.LessonStudents.Remove(lessonStudent);
}
