def test_only_students_courses(self):
"""Only courses from the student are included."""
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school)
course = CourseFactory(grade_levels=[enrollment.grade_level])
grade = GradeFactory(
score=50,
student=enrollment.student,
graded_work__course_task__course=course,
)
grade_2 = GradeFactory(
score=100,
student=enrollment.student,
graded_work__course_task__course=course,
)
GradeFactory(graded_work__course_task__course__grade_levels=[
enrollment.grade_level
])
with self.login(user):
self.get_check_200("reports:progress", pk=enrollment.id)
assert self.get_context("courses") == [{
"course":
grade.graded_work.course_task.course,
"grades": [grade, grade_2],
"course_average":
75,
}]
def test_multiple_averages(self):
"""The average for each course is calculated."""
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school)
GradeFactory(
score=50,
student=enrollment.student,
graded_work__course_task__course__grade_levels=[
enrollment.grade_level
],
)
GradeFactory(
score=100,
student=enrollment.student,
graded_work__course_task__course__grade_levels=[
enrollment.grade_level
],
)
GradeFactory(graded_work__course_task__course__grade_levels=[
enrollment.grade_level
])
with self.login(user):
self.get_check_200("reports:progress", pk=enrollment.id)
assert self.get_context("courses")[0]["course_average"] == 50
assert self.get_context("courses")[1]["course_average"] == 100
def test_course_tasks_context(self):
"""All the task details of an enrolled student are in the context."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
task = CourseTaskFactory(course=course)
enrollment = EnrollmentFactory(grade_level=grade_level)
work = CourseworkFactory(student=enrollment.student, course_task=task)
grade = GradeFactory(student=enrollment.student, graded_work__course_task=task)
url = self.reverse("courses:detail", pk=course.id) + "?completed_tasks=1"
with self.login(user):
self.get_check_200(url)
assert self.get_context("task_details") == [
{
"number": 1,
"task": task,
"complete": True,
"student_details": [
{
"student": enrollment.student,
"assigned": True,
"coursework": work,
"grade": grade,
"planned_date": None,
}
],
}
]
def test_fetch_graded_work(self):
user = self.make_user()
enrollment = EnrollmentFactory(
student__school=user.school,
grade_level__school_year__school=user.school)
student = enrollment.student
grade_level = enrollment.grade_level
course = CourseFactory(grade_levels=[grade_level])
graded_work_1 = GradedWorkFactory(course_task__course=course)
CourseworkFactory(student=student,
course_task=graded_work_1.course_task)
GradeFactory(student=student, graded_work=graded_work_1)
graded_work_2 = GradedWorkFactory(course_task__course=course)
CourseworkFactory(student=student,
course_task=graded_work_2.course_task)
with self.login(user):
self.get("students:grade")
assert self.get_context("work_to_grade") == [{
"student":
student,
"graded_work": [graded_work_2]
}]
assert self.get_context("has_work_to_grade")
def test_course_filter(self):
"""The report can filter to an individual course."""
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school)
student = enrollment.student
course_1 = CourseFactory(grade_levels=[enrollment.grade_level])
course_2 = CourseFactory(grade_levels=[enrollment.grade_level])
GradeFactory(student=student,
graded_work__course_task__course=course_1)
GradeFactory(student=student,
graded_work__course_task__course=course_2)
url = self.reverse("reports:progress", pk=enrollment.id)
url += f"?course={course_1.id}"
with self.login(user):
self.get_check_200(url)
assert len(self.get_context("courses")) == 1
def test_only_students_grades(self):
"""Only grades from the student are included."""
user = self.make_user()
enrollment = EnrollmentFactory(grade_level__school_year__school=user.school)
grade = GradeFactory(
student=enrollment.student,
graded_work__course_task__course__grade_levels=[enrollment.grade_level],
)
GradeFactory(
graded_work__course_task__course__grade_levels=[enrollment.grade_level]
)
with self.login(user):
self.get_check_200(
"reports:progress",
uuid=enrollment.grade_level.school_year.uuid,
student_uuid=enrollment.student.uuid,
)
assert list(self.get_context("grades")) == [grade]
def test_get(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
task = CourseTaskFactory(course=course)
GradeFactory(graded_work__course_task=task)
CourseworkFactory(course_task=task)
CourseResourceFactory(course=course)
with self.login(user):
self.get_check_200("courses:delete", pk=course.id)
assert self.get_context("tasks_count") == 1
assert self.get_context("grades_count") == 1
assert self.get_context("coursework_count") == 1
assert self.get_context("course_resources_count") == 1
def test_fetch_graded_work(self):
user = self.make_user()
student = StudentFactory(school=user.school)
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
graded_work_1 = GradedWorkFactory(course_task__course=course)
CourseworkFactory(student=student, course_task=graded_work_1.course_task)
GradeFactory(student=student, graded_work=graded_work_1)
graded_work_2 = GradedWorkFactory(course_task__course=course)
CourseworkFactory(student=student, course_task=graded_work_2.course_task)
with self.login(user):
self.get("students:grade")
self.assertContext(
"work_to_grade", [{"student": student, "graded_work": [graded_work_2]}]
)
def test_no_grade_when_already_graded(self):
today = timezone.now().date()
user = self.make_user()
school = user.school
student = StudentFactory(school=school)
grade_level = GradeLevelFactory(school_year__school=school)
grade = GradeFactory(
student=student,
graded_work__course_task__course__grade_levels=[grade_level],
)
data = {
"completed_date": "{:%Y-%m-%d}".format(today),
f"task-{student.id}-{grade.graded_work.course_task.id}": "on",
}
with self.login(user):
response = self.post("core:daily", data=data)
self.response_302(response)
assert response.get("Location") == self.reverse("core:daily")
def test_save_update(self):
"""The form updates a grade."""
user = self.make_user()
student = StudentFactory(school=user.school)
grade_level = GradeLevelFactory(school_year__school=user.school)
EnrollmentFactory(student=student, grade_level=grade_level)
course = CourseFactory(grade_levels=[grade_level])
graded_work = GradedWorkFactory(course_task__course=course)
GradeFactory(student=student, graded_work=graded_work)
data = {
"student": str(student.id),
"graded_work": str(graded_work.id),
"score": "100",
}
form = GradeForm(data=data)
form.is_valid()
form.save()
assert (Grade.objects.filter(student=student,
graded_work=graded_work).count() == 1)
def test_only_students_coursework(self):
"""Only coursework from the student is included.
Coursework is added to the grades to display the completed dates.
It is possible for a user to add a grade without the student finishing the task
so the coursework can be None.
"""
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school)
grade = GradeFactory(
student=enrollment.student,
graded_work__course_task__course__grade_levels=[
enrollment.grade_level
],
)
CourseworkFactory(course_task=grade.graded_work.course_task)
with self.login(user):
self.get_check_200("reports:progress", pk=enrollment.id)
assert self.get_context("courses")[0]["grades"][0].coursework is None
def test_factory(self):
grade = GradeFactory()
assert grade is not None
def test_has_uuid(self):
grade_uuid = uuid.uuid4()
grade = GradeFactory(uuid=grade_uuid)
self.assertEqual(grade.uuid, grade_uuid)
def test_has_uuid(self):
grade_uuid = uuid.uuid4()
grade = GradeFactory(uuid=grade_uuid)
assert grade.uuid == grade_uuid
def test_has_score(self):
score = 99
grade = GradeFactory(score=score)
self.assertEqual(grade.score, score)
def test_has_student(self):
student = StudentFactory()
grade = GradeFactory(student=student)
assert grade.student == student
def test_has_student(self):
student = StudentFactory()
grade = GradeFactory(student=student)
self.assertEqual(grade.student, student)
def test_has_graded_work(self):
graded_work = GradedWorkFactory()
grade = GradeFactory(graded_work=graded_work)
assert grade.graded_work == graded_work
def test_has_graded_work(self):
graded_work = GradedWorkFactory()
grade = GradeFactory(graded_work=graded_work)
self.assertEqual(grade.graded_work, graded_work)
def test_has_score(self):
score = 99
grade = GradeFactory(score=score)
assert grade.score == score
def test_factory(self):
grade = GradeFactory()
self.assertIsNotNone(grade)
