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)