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