def test_only_task_for_grade_level(self):
"""Only general tasks and tasks for the student's grade level appear."""
user = self.make_user()
enrollment = EnrollmentFactory(
student__school=user.school,
grade_level__school_year__school=user.school)
course = CourseFactory(grade_levels=[enrollment.grade_level])
general_task = CourseTaskFactory(course=course)
grade_level_task = CourseTaskFactory(
course=course, grade_level=enrollment.grade_level)
CourseTaskFactory(course=course, grade_level=GradeLevelFactory())
with self.login(user):
self.get_check_200("students:course",
uuid=enrollment.student.uuid,
course_uuid=course.uuid)
task_items = self.get_context("task_items")
assert len(task_items) == 2
assert task_items[0]["course_task"] == general_task
assert task_items[1]["course_task"] == grade_level_task
def test_save_existing_coursework(self):
"""A new coursework is created for a student and task."""
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])
course_task = CourseTaskFactory(course=course)
CourseworkFactory(student=student, course_task=course_task)
data = {
"student": str(student.id),
"course_task": str(course_task.id),
"completed_date": str(grade_level.school_year.start_date),
}
form = CourseworkForm(data=data)
form.is_valid()
form.save()
assert (Coursework.objects.filter(
student=student, course_task=course_task).count() == 1)
def test_students_only_enroll_in_one_grade_level_per_year(self):
"""A student can only be enrolled in a single grade level in a school year."""
user = self.make_user()
enrollment = EnrollmentFactory(
student__school=user.school,
grade_level__school_year__school=user.school)
another_grade_level = GradeLevelFactory(
school_year=enrollment.grade_level.school_year)
data = {
"student": str(enrollment.student.id),
"grade_level": str(another_grade_level.id),
}
form = EnrollmentForm(user=user, data=data)
is_valid = form.is_valid()
assert not is_valid
assert (
"A student may not be enrolled in multiple grade levels in a school year. "
f"{enrollment.student} is enrolled in {enrollment.grade_level}."
in form.non_field_errors())
def test_get(self):
user = self.make_user()
school_year = SchoolYearFactory(school=user.school)
enrollment = EnrollmentFactory(grade_level__school_year=school_year)
course = CourseFactory(grade_levels=[enrollment.grade_level],
days_of_week=Course.ALL_DAYS)
coursework = CourseworkFactory(course_task__course=course)
with self.login(user):
self.get_check_200("schools:school_year_forecast",
pk=school_year.id)
assert self.get_context("schoolyear") == school_year
assert self.get_context("students") == [{
"student":
enrollment.student,
"courses": [{
"course": course,
"last_forecast_date": coursework.completed_date
}],
}]
def test_planned_dates_for_future_school_years(self):
"""The planned dates for a future school year match with the year."""
today = timezone.localdate()
user = self.make_user()
school_year = SchoolYearFactory(
school=user.school,
start_date=today + relativedelta(years=1, month=1, day=1),
end_date=today + relativedelta(years=1, month=12, day=31),
days_of_week=SchoolYear.ALL_DAYS,
)
enrollment = EnrollmentFactory(student__school=user.school,
grade_level__school_year=school_year)
course = CourseFactory(grade_levels=[enrollment.grade_level],
days_of_week=Course.ALL_DAYS)
CourseTaskFactory(course=course)
forecaster = Forecaster()
items = forecaster.get_task_items(enrollment.student, course)
task_item = items[0]
assert task_item["planned_date"] == school_year.start_date
def test_no_forecast_course_not_running(self):
"""A course that isn't running will not forecast dates."""
today = timezone.localdate()
user = self.make_user()
school_year = SchoolYearFactory(
school=user.school,
start_date=today + relativedelta(years=1, month=1, day=1),
end_date=today + relativedelta(years=1, month=12, day=31),
days_of_week=SchoolYear.ALL_DAYS,
)
enrollment = EnrollmentFactory(student__school=user.school,
grade_level__school_year=school_year)
course = CourseFactory(grade_levels=[enrollment.grade_level],
days_of_week=Course.NO_DAYS)
CourseTaskFactory(course=course)
forecaster = Forecaster()
items = forecaster.get_task_items(enrollment.student, course)
task_item = items[0]
assert "planned_date" not in task_item
def test_not_graded_work_from_other_school(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)
graded_work_2 = GradedWorkFactory()
CourseworkFactory(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_1]
}])
def test_post(self):
"""A POST creates a coursework."""
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])
course_task = CourseTaskFactory(course=course)
data = {"completed_date": str(grade_level.school_year.start_date)}
with self.login(user):
response = self.post(
"students:coursework",
pk=student.id,
course_task_id=course_task.id,
data=data,
)
self.response_302(response)
assert (Coursework.objects.filter(
student=student, course_task=course_task).count() == 1)
def test_get_day_coursework(self):
today = timezone.now().date()
monday = today + relativedelta(weekday=MO(-1))
enrollment = EnrollmentFactory(
grade_level__school_year__start_date=today -
datetime.timedelta(days=30))
student = enrollment.student
school_year = enrollment.grade_level.school_year
GradeLevelFactory(school_year=school_year)
course = CourseFactory()
course.grade_levels.add(enrollment.grade_level)
coursework_1 = CourseworkFactory(student=student,
course_task__course=course,
completed_date=monday)
coursework_2 = CourseworkFactory(student=student,
course_task__course=course,
completed_date=monday)
day_coursework = student.get_day_coursework(monday)
assert day_coursework == {course.id: [coursework_1, coursework_2]}
def test_save(self):
"""The form creates a new 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)
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,
score=100).count() == 1)
def test_planned_dates_for_future_school_years(self):
"""The planned dates for a future school year match with the year."""
today = timezone.localdate()
user = self.make_user()
school_year = SchoolYearFactory(
school=user.school,
start_date=today + relativedelta(years=1, month=1, day=1),
end_date=today + relativedelta(years=1, month=12, day=31),
days_of_week=SchoolYear.ALL_DAYS,
)
enrollment = EnrollmentFactory(student__school=user.school,
grade_level__school_year=school_year)
course = CourseFactory(grade_levels=[enrollment.grade_level])
CourseTaskFactory(course=course)
with self.login(user):
self.get_check_200("students:course",
uuid=enrollment.student.uuid,
course_uuid=course.uuid)
task_item = self.get_context("task_items")[0]
assert task_item["planned_date"] == school_year.start_date
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_post(self):
"""A POST creates 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])
course_task = CourseTaskFactory(course=course)
graded_work = GradedWorkFactory(course_task=course_task)
data = {"score": "100"}
with self.login(user):
response = self.post(
"students:grade_task",
pk=student.id,
course_task_id=course_task.id,
data=data,
)
self.response_302(response)
assert (Grade.objects.filter(student=student,
graded_work=graded_work).count() == 1)
def test_grade_next(self):
"""A graded task sends the user to the grade page after submission."""
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])
course_task = CourseTaskFactory(course=course)
GradedWorkFactory(course_task=course_task)
data = {"completed_date": str(grade_level.school_year.start_date)}
with self.login(user):
response = self.post(
"students:coursework",
pk=student.id,
course_task_id=course_task.id,
data=data,
)
self.response_302(response)
grade_url = self.reverse("students:grade")
assert grade_url in response.get("Location")
def test_has_tasks_today(self):
"""A course that runs today shows its tasks."""
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])
task = CourseTaskFactory(course=course)
today = timezone.now().date()
with self.login(user):
self.get("students:course",
uuid=student.uuid,
course_uuid=course.uuid)
assert self.get_context("task_items") == [{
"course_task": task,
"planned_date": today,
"has_graded_work": False
}]
def test_future_school_year_advanced_week(self):
"""Looking ahead in a future school year calculates offsets from year start.
This is slightly different from looking at the first week of a school year
that has a starting day before the school year starts. The primary functional
difference is that the future school year will appear in the `schedules`
context instead of `next_year_schedules` context.
"""
today = timezone.localdate()
user = self.make_user()
school_year = SchoolYearFactory(
school=user.school,
start_date=today + relativedelta(years=1, month=1, day=1),
end_date=today + relativedelta(years=1, month=12, day=31),
# Running only on the last possible day should guarantee 1 task/week.
days_of_week=SchoolYear.SATURDAY,
)
enrollment = EnrollmentFactory(
grade_level__school_year=school_year, student__school=user.school
)
course = CourseFactory(
grade_levels=[enrollment.grade_level], days_of_week=Course.SATURDAY
)
CourseTaskFactory(course=course)
task = CourseTaskFactory(course=course)
week = Week(school_year.start_date)
first_day = week.first_day + datetime.timedelta(days=7)
with self.login(user):
self.get(
"core:weekly",
year=first_day.year,
month=first_day.month,
day=first_day.day,
)
schedule = self.get_context("schedules")[0]
assert schedule["courses"][0]["days"][0]["task"] == task
def test_has_tasks_with_completed(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],
days_of_week=Course.WEDNESDAY + Course.THURSDAY)
task_1 = CourseTaskFactory(course=course)
coursework = CourseworkFactory(course_task=task_1, student=student)
task_2 = CourseTaskFactory(course=course)
GradedWorkFactory(course_task=task_2)
today = timezone.now().date() + datetime.timedelta(days=2)
with self.login(user):
self.get_check_200(
"students:course",
uuid=student.uuid,
course_uuid=course.uuid,
data={"completed_tasks": "1"},
)
self.assertContext(
"task_items",
[
{
"course_task": task_1,
"coursework": coursework,
"has_graded_work": False,
},
{
"course_task": task_2,
"planned_date": today,
"has_graded_work": True
},
],
)
def test_get_week_with_breaks(self):
"""Next week starts with the correct task when the current week has breaks."""
today = timezone.now().date()
next_week = Week(today + datetime.timedelta(days=7))
enrollment = EnrollmentFactory()
school_year = enrollment.grade_level.school_year
student = enrollment.student
course = CourseFactory(grade_levels=[enrollment.grade_level])
CourseworkFactory(student=student,
course_task__course=course,
completed_date=today)
task = CourseTaskFactory(course=course)
CourseTaskFactory(course=course)
SchoolBreakFactory(
school_year=school_year,
start_date=today + datetime.timedelta(days=1),
end_date=today + datetime.timedelta(days=2),
)
week_schedule = student.get_week_schedule(school_year, today,
next_week)
assert week_schedule["courses"][0]["days"][0]["task"] == task
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_future_school_year(self):
"""A future school year displays the expected task on a day."""
today = timezone.localdate()
user = self.make_user()
school_year = SchoolYearFactory(
school=user.school,
start_date=today + relativedelta(years=1, month=1, day=1),
end_date=today + relativedelta(years=1, month=12, day=31),
days_of_week=SchoolYear.ALL_DAYS,
)
enrollment = EnrollmentFactory(grade_level__school_year=school_year)
task = CourseTaskFactory(course__grade_levels=[enrollment.grade_level])
with self.login(user):
self.get(
"core:daily_for_date",
year=school_year.start_date.year,
month=school_year.start_date.month,
day=school_year.start_date.day,
)
schedule = self.get_context("schedules")[0]
assert schedule["courses"][0].get("task") == task
def test_no_forecast_course_not_running(self):
"""A course that isn't running will not forecast dates."""
today = timezone.localdate()
user = self.make_user()
school_year = SchoolYearFactory(
school=user.school,
start_date=today + relativedelta(years=1, month=1, day=1),
end_date=today + relativedelta(years=1, month=12, day=31),
days_of_week=SchoolYear.ALL_DAYS,
)
enrollment = EnrollmentFactory(student__school=user.school,
grade_level__school_year=school_year)
course = CourseFactory(grade_levels=[enrollment.grade_level],
days_of_week=Course.NO_DAYS)
CourseTaskFactory(course=course)
with self.login(user):
self.get_check_200("students:course",
uuid=enrollment.student.uuid,
course_uuid=course.uuid)
task_item = self.get_context("task_items")[0]
assert "planned_date" not in task_item
def test_get_week_coursework(self):
today = timezone.now().date()
week = Week(today)
enrollment = EnrollmentFactory(
grade_level__school_year__start_date=today - datetime.timedelta(days=30)
)
student = enrollment.student
school_year = enrollment.grade_level.school_year
GradeLevelFactory(school_year=school_year)
course = CourseFactory()
course.grade_levels.add(enrollment.grade_level)
coursework_1 = CourseworkFactory(
student=student, course_task__course=course, completed_date=week.first_day
)
coursework_2 = CourseworkFactory(
student=student, course_task__course=course, completed_date=week.first_day
)
week_coursework = student.get_week_coursework(week)
assert week_coursework == {
course.id: {week.first_day: [coursework_1, coursework_2]}
}
def test_get_week_coursework(self):
today = timezone.now().date()
monday = today + relativedelta(weekday=MO(-1))
sunday = today + relativedelta(weekday=SU(+1))
week = (monday, sunday)
enrollment = EnrollmentFactory(
grade_level__school_year__start_date=today - datetime.timedelta(days=30)
)
student = enrollment.student
school_year = enrollment.grade_level.school_year
GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_level=enrollment.grade_level)
coursework_1 = CourseworkFactory(
student=student, course_task__course=course, completed_date=monday
)
coursework_2 = CourseworkFactory(
student=student, course_task__course=course, completed_date=monday
)
week_coursework = student.get_week_coursework(week)
self.assertEqual(
week_coursework, {course.id: {monday: [coursework_1, coursework_2]}}
)
def test_has_tasks_with_completed(self):
"""Completed tasks appear in the context when the query flag is present."""
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])
task_1 = CourseTaskFactory(course=course)
coursework = CourseworkFactory(course_task=task_1, student=student)
task_2 = CourseTaskFactory(course=course)
GradedWorkFactory(course_task=task_2)
tuesday = timezone.localdate() + datetime.timedelta(days=1)
with self.login(user):
self.get_check_200(
"students:course",
uuid=student.uuid,
course_uuid=course.uuid,
data={"completed_tasks": "1"},
)
assert coursework.completed_date == timezone.localdate()
assert self.get_context("task_items") == [
{
"course_task": task_1,
"coursework": coursework,
"has_graded_work": False
},
{
"course_task": task_2,
"planned_date": tuesday,
"has_graded_work": True
},
]
def test_has_grade_level(self):
grade_level = GradeLevelFactory()
enrollment = EnrollmentFactory(grade_level=grade_level)
assert enrollment.grade_level == grade_level
def test_has_student(self):
student = StudentFactory()
enrollment = EnrollmentFactory(student=student)
assert enrollment.student == student
def test_factory(self):
enrollment = EnrollmentFactory()
assert enrollment is not None
def test_has_student(self):
student = StudentFactory()
enrollment = EnrollmentFactory(student=student)
self.assertEqual(enrollment.student, student)
def test_has_grade_level(self):
grade_level = GradeLevelFactory()
enrollment = EnrollmentFactory(grade_level=grade_level)
self.assertEqual(enrollment.grade_level, grade_level)
def test_unauthenticated_access(self):
enrollment = EnrollmentFactory()
self.assertLoginRequired("reports:attendance", pk=enrollment.id)
