def test_has_schedules(self, timezone):
now = datetime.datetime(2020, 1, 24, tzinfo=pytz.utc)
friday = now.date()
timezone.localdate.return_value = now.date()
user = self.make_user()
student = StudentFactory(school=user.school)
school_year = SchoolYearFactory(
school=user.school,
start_date=friday - datetime.timedelta(days=90),
end_date=friday + datetime.timedelta(days=90),
days_of_week=SchoolYear.FRIDAY,
)
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_level=grade_level,
days_of_week=Course.FRIDAY)
task_1 = CourseTaskFactory(course=course)
coursework = CourseworkFactory(student=student,
course_task=task_1,
completed_date=friday)
course_2 = CourseFactory(grade_level=grade_level,
days_of_week=Course.FRIDAY)
task_2a = CourseTaskFactory(course=course_2)
CourseworkFactory(
student=student,
course_task=task_2a,
completed_date=friday - datetime.timedelta(days=1),
)
task_2b = CourseTaskFactory(course=course_2)
course_3 = CourseFactory(grade_level=grade_level,
days_of_week=Course.THURSDAY)
CourseTaskFactory(course=course_3)
course_4 = CourseFactory(grade_level=grade_level,
days_of_week=Course.FRIDAY)
EnrollmentFactory(student=student, grade_level=grade_level)
with self.login(user):
self.get("core:daily")
expected_schedule = {
"student":
student,
"courses": [
{
"course": course,
"coursework": [coursework]
},
{
"course": course_2,
"task": task_2b
},
{
"course": course_3
},
{
"course": course_4,
"task": None
},
],
}
self.assertContext("schedules", [expected_schedule])
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_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_grades_in_course_order(self):
"""The grades are in the course order set by the user.
Courses have a set order for a grade level that users can adjust.
Customers would like to see the things to grade in the same ordering scheme.
"""
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_1 = CourseFactory(grade_levels=[grade_level])
graded_work_1 = GradedWorkFactory(course_task__course=course_1)
CourseworkFactory(student=student,
course_task=graded_work_1.course_task)
course_2 = CourseFactory(grade_levels=[grade_level])
graded_work_2 = GradedWorkFactory(course_task__course=course_2)
CourseworkFactory(student=student,
course_task=graded_work_2.course_task)
grade_level.move_course_down(course_1)
with self.login(user):
self.get("students:grade")
assert self.get_context("work_to_grade") == [{
"student":
student,
"graded_work": [graded_work_2, graded_work_1]
}]
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_schedules(self, mock_timezone):
friday = timezone.localdate() + relativedelta(weekday=FR)
mock_timezone.localdate.return_value = friday
user = self.make_user()
student = StudentFactory(school=user.school)
school_year = SchoolYearFactory(school=user.school,
days_of_week=SchoolYear.FRIDAY)
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_levels=[grade_level],
days_of_week=Course.FRIDAY)
task_1 = CourseTaskFactory(course=course)
coursework = CourseworkFactory(student=student,
course_task=task_1,
completed_date=friday)
course_2 = CourseFactory(grade_levels=[grade_level],
days_of_week=Course.FRIDAY)
task_2a = CourseTaskFactory(course=course_2)
CourseworkFactory(
student=student,
course_task=task_2a,
completed_date=friday - datetime.timedelta(days=1),
)
task_2b = CourseTaskFactory(course=course_2)
course_3 = CourseFactory(grade_levels=[grade_level],
days_of_week=Course.THURSDAY)
CourseTaskFactory(course=course_3)
course_4 = CourseFactory(grade_levels=[grade_level],
days_of_week=Course.FRIDAY)
EnrollmentFactory(student=student, grade_level=grade_level)
with self.login(user):
self.get("core:daily")
expected_schedule = {
"student":
student,
"courses": [
{
"course": course,
"coursework": [coursework]
},
{
"course": course_2,
"task": task_2b
},
{
"course": course_3
},
{
"course": course_4,
"no_scheduled_task": True
},
],
}
self.assertContext("schedules", [expected_schedule])
def test_no_tasks_in_past_week(self, timezone):
now = datetime.datetime(2020, 1, 26, tzinfo=pytz.utc)
sunday = now.date()
monday = sunday - datetime.timedelta(days=6)
timezone.localdate.return_value = now.date()
user = self.make_user()
student = StudentFactory(school=user.school)
school_year = SchoolYearFactory(
school=user.school,
start_date=sunday - datetime.timedelta(days=90),
end_date=sunday + datetime.timedelta(days=90),
days_of_week=SchoolYear.MONDAY + SchoolYear.TUESDAY +
SchoolYear.WEDNESDAY + SchoolYear.THURSDAY + SchoolYear.FRIDAY,
)
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(
grade_level=grade_level,
days_of_week=Course.MONDAY + Course.WEDNESDAY + Course.THURSDAY +
Course.FRIDAY,
)
task_1 = CourseTaskFactory(course=course)
CourseTaskFactory(course=course)
CourseworkFactory(
student=student,
course_task=task_1,
completed_date=monday - datetime.timedelta(days=7),
)
EnrollmentFactory(student=student, grade_level=grade_level)
with self.login(user):
self.get("core:weekly", year=2020, month=1, day=13)
schedules = self.get_context("schedules")
# Day 0 has coursework. Day 1 should show no task.
self.assertNotIn("task", schedules[0]["courses"][0]["days"][1])
def test_has_tasks(self):
user = self.make_user()
student = StudentFactory(school=user.school)
course = CourseFactory(
grade_level__school_year__school=user.school,
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)
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)
self.assertContext(
"task_items",
[
{
"course_task": task_1,
"coursework": coursework
},
{
"course_task": task_2,
"planned_date": today
},
],
)
def test_has_tasks(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)
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)
self.assertContext(
"task_items",
[{
"course_task": task_2,
"planned_date": today,
"has_graded_work": True
}],
)
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",
pk=student.id,
course_id=course.id,
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_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_week_schedule_tasks_after_last_coursework(self):
"""Remaining tasks should only appear after the last completed coursework."""
today = timezone.localdate()
sunday = today + relativedelta(weekday=SU(-1))
week = Week(sunday)
enrollment = EnrollmentFactory(
grade_level__school_year__days_of_week=SchoolYear.ALL_DAYS
)
student = enrollment.student
school_year = enrollment.grade_level.school_year
completed_task = CourseTaskFactory(
course__days_of_week=Course.ALL_DAYS,
course__grade_levels=[enrollment.grade_level],
)
coursework = CourseworkFactory(
student=student,
course_task=completed_task,
completed_date=sunday + datetime.timedelta(days=1),
)
to_do_task = CourseTaskFactory(course=completed_task.course)
week_schedule = student.get_week_schedule(school_year, sunday, week)
assert week_schedule["courses"][0]["days"][1]["coursework"] == [coursework]
assert week_schedule["courses"][0]["days"][2]["task"] == to_do_task
def test_school_dates(self):
"""The dates on the report have the expected states."""
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school)
school_year = enrollment.grade_level.school_year
SchoolBreakFactory(
school_year=school_year,
start_date=school_year.start_date,
end_date=school_year.start_date,
)
CourseworkFactory(
student=enrollment.student,
course_task__course__grade_levels=[enrollment.grade_level],
completed_date=school_year.start_date + datetime.timedelta(days=1),
)
with self.login(user):
self.get_check_200("reports:attendance", pk=enrollment.id)
school_dates = self.get_context("school_dates")
assert school_dates[0]["is_break"]
assert school_dates[1]["attended"]
assert not school_dates[4]["is_school_day"] # First Saturday
assert self.get_context("total_days_attended") == 1
def test_no_tasks_in_past_week(self, timezone):
now = datetime.datetime(2020, 1, 26, tzinfo=pytz.utc)
sunday = now.date()
monday = sunday - datetime.timedelta(days=6)
timezone.localdate.return_value = now.date()
user = self.make_user()
student, grade_level = self.make_student_enrolled_in_grade_level(user, sunday)
course = CourseFactory(
grade_levels=[grade_level],
days_of_week=Course.MONDAY
+ Course.WEDNESDAY
+ Course.THURSDAY
+ Course.FRIDAY,
)
task_1 = CourseTaskFactory(course=course)
CourseTaskFactory(course=course)
CourseworkFactory(
student=student,
course_task=task_1,
completed_date=monday - datetime.timedelta(days=7),
)
with self.login(user):
self.get("core:weekly", year=2020, month=1, day=13)
schedules = self.get_context("schedules")
# Day 0 has coursework. Day 1 should show no task.
assert "task" not in schedules[0]["courses"][0]["days"][1]
def test_not_graded_work_from_other_school(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)
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_has_schedules(self, timezone):
now = datetime.datetime(2020, 1, 26, tzinfo=pytz.utc)
sunday = now.date()
monday = sunday - datetime.timedelta(days=6)
timezone.localdate.return_value = now.date()
user = self.make_user()
student = StudentFactory(school=user.school)
school_year = SchoolYearFactory(
school=user.school,
start_date=sunday - datetime.timedelta(days=90),
end_date=sunday + datetime.timedelta(days=90),
days_of_week=SchoolYear.MONDAY + SchoolYear.TUESDAY +
SchoolYear.WEDNESDAY + SchoolYear.THURSDAY + SchoolYear.FRIDAY,
)
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(
grade_level=grade_level,
days_of_week=Course.MONDAY + Course.WEDNESDAY + Course.THURSDAY +
Course.FRIDAY,
)
task_1 = CourseTaskFactory(course=course)
task_2 = CourseTaskFactory(course=course)
task_3 = CourseTaskFactory(course=course)
coursework = CourseworkFactory(student=student,
course_task=task_1,
completed_date=monday)
EnrollmentFactory(student=student, grade_level=grade_level)
with self.login(user), self.assertNumQueries(11):
self.get("core:app")
expected_schedule = {
"student":
student,
"courses": [{
"course":
course,
"days": [
{
"week_date": monday,
"coursework": [coursework]
},
{
"week_date": monday + datetime.timedelta(days=1)
},
{
"week_date": monday + datetime.timedelta(days=2),
"task": task_2,
},
{
"week_date": monday + datetime.timedelta(days=3),
"task": task_3,
},
{
"week_date": monday + datetime.timedelta(days=4)
},
],
}],
}
self.assertContext("schedules", [expected_schedule])
def test_far_future_day_schedule(self, timezone):
now = datetime.datetime(2020, 1, 23, tzinfo=pytz.utc)
thursday = now.date()
timezone.localdate.return_value = now.date()
user = self.make_user()
student = StudentFactory(school=user.school)
school_year = SchoolYearFactory(
school=user.school,
start_date=thursday - datetime.timedelta(days=90),
end_date=thursday + datetime.timedelta(days=90),
)
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_levels=[grade_level])
CourseworkFactory(
student=student,
course_task__course=course,
completed_date=thursday - datetime.timedelta(days=1),
)
CourseTaskFactory(course=course) # current task for thursday
CourseTaskFactory(course=course) # projected task for friday
task = CourseTaskFactory(course=course)
EnrollmentFactory(student=student, grade_level=grade_level)
with self.login(user):
self.get("core:daily_for_date", year=2020, month=1, day=27)
expected_schedule = {
"student": student,
"courses": [{"course": course, "task": task}],
}
self.assertContext("schedules", [expected_schedule])
def test_task_complete_both_students_done(self):
"""When all students are done with a task, it is marked complete."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
task = CourseTaskFactory(course=course)
enrollment_1 = EnrollmentFactory(grade_level=grade_level)
CourseworkFactory(student=enrollment_1.student, course_task=task)
enrollment_2 = EnrollmentFactory(grade_level=grade_level)
CourseworkFactory(student=enrollment_2.student, course_task=task)
url = self.reverse("courses:detail", pk=course.id) + "?completed_tasks=1"
with self.login(user):
self.get_check_200(url)
detail = self.get_context("task_details")[0]
assert detail["complete"]
def test_weekly(self, timezone):
"""The weekly schedule is available in the context."""
now = datetime.datetime(2020, 1, 24, tzinfo=pytz.utc) # A Friday
friday = now.date()
monday = friday - datetime.timedelta(days=4)
timezone.localdate.return_value = now.date()
user = self.make_user()
student, grade_level = self.make_student_enrolled_in_grade_level(
user, friday)
course = CourseFactory(
grade_levels=[grade_level],
days_of_week=Course.MONDAY + Course.WEDNESDAY + Course.THURSDAY +
Course.FRIDAY,
)
task_1 = CourseTaskFactory(course=course)
CourseTaskFactory(course=course)
CourseTaskFactory(course=course)
CourseTaskFactory(course=course)
task_2 = CourseTaskFactory(course=course)
CourseworkFactory(student=student,
course_task=task_1,
completed_date=monday)
with self.login(user), self.assertNumQueries(13):
self.get("core:weekly", year=2020, month=1, day=27)
expected_schedule = {
"student":
student,
"courses": [{
"course":
course,
"days": [
{
"week_date": monday + datetime.timedelta(days=7),
"school_break": None,
"task": task_2,
},
{
"week_date": monday + datetime.timedelta(days=8),
"school_break": None,
},
{
"week_date": monday + datetime.timedelta(days=9),
"school_break": None,
},
{
"week_date": monday + datetime.timedelta(days=10),
"school_break": None,
},
{
"week_date": monday + datetime.timedelta(days=11),
"school_break": None,
},
],
}],
}
assert self.get_context("schedules") == [expected_schedule]
def test_has_schedules(self, timezone):
now = datetime.datetime(2020, 1, 24, tzinfo=pytz.utc)
friday = now.date()
monday = friday - datetime.timedelta(days=4)
timezone.localdate.return_value = now.date()
user = self.make_user()
student, grade_level = self.make_student_enrolled_in_grade_level(
user, friday)
course = CourseFactory(
grade_levels=[grade_level],
days_of_week=Course.MONDAY + Course.WEDNESDAY + Course.THURSDAY +
Course.FRIDAY,
)
task_1 = CourseTaskFactory(course=course)
task_2 = CourseTaskFactory(course=course)
task_3 = CourseTaskFactory(course=course)
coursework = CourseworkFactory(student=student,
course_task=task_1,
completed_date=monday)
with self.login(user), self.assertNumQueries(12):
self.get("core:app")
expected_schedule = {
"student":
student,
"courses": [{
"course":
course,
"days": [
{
"week_date": monday,
"coursework": [coursework]
},
{
"week_date": monday + datetime.timedelta(days=1)
},
{
"week_date": monday + datetime.timedelta(days=2),
"task": task_2,
},
{
"week_date": monday + datetime.timedelta(days=3),
"task": task_3,
},
{
"week_date": monday + datetime.timedelta(days=4)
},
],
}],
}
schedules = self.get_context("schedules")
assert schedules == [expected_schedule]
def test_all_tasks_completed(self):
"""The last date matched the coursework completion."""
enrollment = EnrollmentFactory()
student = enrollment.student
course = CourseFactory(grade_levels=[enrollment.grade_level])
task = CourseTaskFactory(course=course)
coursework = CourseworkFactory(student=student, course_task=task)
forecaster = Forecaster()
last_date = forecaster.get_last_forecast_date(student, course)
assert last_date == coursework.completed_date
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_fetch_graded_work(self):
user = self.make_user()
student = StudentFactory(school=user.school)
school_year = SchoolYearFactory(school=user.school)
graded_work_1 = GradedWorkFactory(
course_task__course__grade_level__school_year=school_year)
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__grade_level__school_year=school_year)
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_hide_complete_tasks(self):
"""With students enrolled, completed tasks are hidden by default."""
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)
CourseworkFactory(student=enrollment.student, course_task=task)
with self.login(user):
self.get_check_200("courses:detail", pk=course.id)
assert not self.get_context("task_details")
def test_task_complete_one_student_coursework(self):
"""When a student has not completed, the task is marked incomplete."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
task = CourseTaskFactory(course=course)
EnrollmentFactory(grade_level=grade_level)
enrollment = EnrollmentFactory(grade_level=grade_level)
CourseworkFactory(student=enrollment.student, course_task=task)
with self.login(user):
self.get_check_200("courses:detail", pk=course.id)
detail = self.get_context("task_details")[0]
assert not detail["complete"]
def test_incomplete_daily(self):
today = timezone.now().date()
user = self.make_user()
student = StudentFactory(school=user.school)
grade_level = GradeLevelFactory(school_year__school=user.school)
task = CourseTaskFactory(course__grade_levels=[grade_level])
CourseworkFactory(student=student, course_task=task)
data = {
"completed_date": "{:%Y-%m-%d}".format(today),
f"task-{student.id}-{task.id}": "off",
}
with self.login(user):
self.post("core:daily", data=data)
assert not Coursework.objects.filter(student=student, course_task=task).exists()
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_task_complete_grade_specific_task(self):
"""A grade specific task is complete when the students in the grade are done."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
other_grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level, other_grade_level])
task = CourseTaskFactory(course=course, grade_level=grade_level)
enrollment = EnrollmentFactory(grade_level=grade_level)
CourseworkFactory(student=enrollment.student, course_task=task)
EnrollmentFactory(grade_level=other_grade_level)
url = self.reverse("courses:detail", pk=course.id) + "?completed_tasks=1"
with self.login(user):
self.get_check_200(url)
detail = self.get_context("task_details")[0]
assert detail["complete"]
def test_save_deletes_coursework(self):
"""A blank completed date deletes an existing 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)
CourseworkFactory(student=student, course_task=course_task)
data = {
"student": str(student.id),
"course_task": str(course_task.id),
}
form = CourseworkForm(data=data)
form.is_valid()
form.save()
assert (Coursework.objects.filter(
student=student, course_task=course_task).count() == 0)
def test_get_incomplete_task_count_in_range(self):
"""The student can get the count of incomplete tasks for a course."""
enrollment = EnrollmentFactory(
grade_level__school_year__days_of_week=SchoolYear.ALL_DAYS)
school_year = enrollment.grade_level.school_year
student = enrollment.student
course = CourseFactory(grade_levels=[enrollment.grade_level],
days_of_week=Course.ALL_DAYS)
coursework = CourseworkFactory(student=student,
course_task__course=course)
CourseTaskFactory(course=course)
incomplete_task_count = student.get_incomplete_task_count_in_range(
course,
coursework.completed_date,
coursework.completed_date + datetime.timedelta(days=1),
school_year,
)
assert incomplete_task_count == 1
