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_has_previous_week_date(self, timezone): user = self.make_user() now = datetime.datetime(2020, 1, 26, tzinfo=pytz.utc) sunday = now.date() + relativedelta(weekday=SU(-1)) previous_sunday = sunday - datetime.timedelta(days=7) timezone.localdate.return_value = now.date() SchoolYearFactory( school=user.school, start_date=now, end_date=now + datetime.timedelta(days=1), ) StudentFactory(school=user.school) with self.login(user): self.get("core:app") self.assertContext("previous_week_date", previous_sunday)
def test_post(self): user = self.make_user() student = StudentFactory(school=user.school) grade_level = GradeLevelFactory(school_year__school=user.school) data = {"student": str(student.id), "grade_level": str(grade_level.id)} with self.login(user): self.post( "students:student_enrollment_create", pk=student.id, school_year_id=grade_level.school_year.id, data=data, ) assert Enrollment.objects.filter( student=student, grade_level=grade_level ).exists()
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_post(self): user = self.make_user() student = StudentFactory(school=user.school) grade_level = GradeLevelFactory(school_year__school=user.school) data = {"student": str(student.id), "grade_level": str(grade_level.id)} with self.login(user): response = self.post( "students:enrollment_create", school_year_id=grade_level.school_year.id, data=data, ) assert Enrollment.objects.filter(student=student, grade_level=grade_level).exists() assert response.get("Location") == self.reverse( "schools:school_year_detail", pk=grade_level.school_year.id)
def test_to_grade(self): today = timezone.now().date() user = self.make_user() student = StudentFactory(school=user.school) graded_work = GradedWorkFactory( course_task__course__grade_level__school_year__school=user.school) data = { "completed_date": "{:%Y-%m-%d}".format(today), f"task-{student.id}-{graded_work.course_task.id}": "on", } with self.login(user): response = self.post("core:daily", data=data) self.response_302(response) url = self.reverse("students:grade") self.assertIn(url, response.get("Location"))
def test_get(self): user = self.make_user() student = StudentFactory(school=user.school) grade_level = GradeLevelFactory(school_year__school=user.school) course = CourseFactory(grade_levels=[grade_level]) course_task = CourseTaskFactory(course=course) GradedWorkFactory(course_task=course_task) with self.login(user): self.get_check_200( "students:grade_task", uuid=student.uuid, course_task_uuid=course_task.uuid, ) assert self.get_context("student") == student assert self.get_context("course_task") == course_task
def test_surrounding_dates_no_current_school_year(self): """When there is no current school year, pull the dates from today.""" user = self.make_user() today = timezone.localdate() SchoolYearFactory( school=user.school, start_date=today - datetime.timedelta(days=5), end_date=today - datetime.timedelta(days=1), ) StudentFactory(school=user.school) with self.login(user): self.get("core:daily") self.assertContext("ereyesterday", today - datetime.timedelta(days=2)) self.assertContext("yesterday", today - datetime.timedelta(days=1)) self.assertContext("tomorrow", today + datetime.timedelta(days=1)) self.assertContext("overmorrow", today + datetime.timedelta(days=2))
def test_not_graded_work_from_other_school(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) 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_no_double_enrollment(self): """A user can not enroll a student twice.""" user = self.make_user() student = StudentFactory(school=user.school) grade_level = GradeLevelFactory(school_year__school=user.school) EnrollmentFactory(student=student, grade_level=grade_level) data = {"student": str(student.id), "grade_level": str(grade_level.id)} with self.login(user): self.post( "students:enrollment_create", uuid=student.uuid, school_year_uuid=grade_level.school_year.uuid, data=data, ) form = self.get_context("form") assert "already exists" in form.errors["__all__"][0]
def test_invalid_completed_date(self): """An invalid completed date is an error.""" 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 = { "student": str(student.id), "course_task": str(course_task.id), "completed_date": "boom", } form = CourseworkForm(data=data) is_valid = form.is_valid() assert not is_valid
def test_multiple_grade_levels(self): """A task that belongs to multiple grade levels can be displayed. This is a regression test for https://rollbar.com/SchoolDesk/schooldesk/items/6/ """ user = self.make_user() student = StudentFactory(school=user.school) 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]) course_task = CourseTaskFactory(course=course) with self.login(user): self.get_check_200( "students:coursework", pk=student.id, course_task_id=course_task.id ) assert self.get_context("course_task") == course_task
def test_is_valid(self): """The coursework validates.""" 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 = { "student": str(student.id), "course_task": str(course_task.id), "completed_date": str(grade_level.school_year.start_date), } form = CourseworkForm(data=data) is_valid = form.is_valid() assert is_valid
def test_invalid_grade_level_submission(self): """An invalid POST for a grade level is rejected.""" user = self.make_user() student = StudentFactory(school=user.school) grade_level = GradeLevelFactory(school_year__school=user.school) other_grade_level = GradeLevelFactory() data = {"student": str(student.id), "grade_level": str(other_grade_level.id)} with self.login(user): self.post( "students:student_enrollment_create", pk=student.id, school_year_id=grade_level.school_year.id, data=data, ) form = self.get_context("form") assert "You may not enroll to that grade level." in form.errors["__all__"][0]
def test_is_valid(self): """The new grade validates.""" 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) is_valid = form.is_valid() assert is_valid
def test_grade(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 = GradedWorkFactory(course_task__course=course) graded_work_2 = GradedWorkFactory(course_task__course=course) data = { f"graded_work-{student.id}-{graded_work.id}": "100", f"graded_work-{student.id}-{graded_work_2.id}": "", } with self.login(user): response = self.post("students:grade", data=data) self.response_302(response) assert response.get("Location") == self.reverse("core:daily") grade = Grade.objects.get(student=student, graded_work=graded_work) assert grade.score == 100
def test_has_days(self, timezone): """The context has the first and last day of the week.""" user = self.make_user() now = datetime.datetime(2020, 1, 26, tzinfo=pytz.utc) first_day = now.date() + relativedelta(weekday=SU(-1)) last_day = now.date() + relativedelta(weekday=SA(+1)) timezone.localdate.return_value = now.date() SchoolYearFactory( school=user.school, start_date=now, end_date=now + datetime.timedelta(days=1), ) StudentFactory(school=user.school) with self.login(user): self.get("core:dashboard") assert self.get_context("first_day") == first_day assert self.get_context("last_day") == last_day
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_redirect_next(self): next_url = "/another/location/" 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 = {"score": "100"} url = self.reverse( "students:grade_task", pk=student.id, course_task_id=course_task.id ) url += f"?next={next_url}" with self.login(user): response = self.post(url, data=data) self.response_302(response) assert next_url in response.get("Location")
def test_grade(self): user = self.make_user() student = StudentFactory(school=user.school) school_year = SchoolYearFactory(school=user.school) graded_work = GradedWorkFactory( course_task__course__grade_level__school_year=school_year) graded_work_2 = GradedWorkFactory( course_task__course__grade_level__school_year=school_year) data = { f"graded_work-{student.id}-{graded_work.id}": "100", f"graded_work-{student.id}-{graded_work_2.id}": "", } with self.login(user): response = self.post("students:grade", data=data) self.response_302(response) self.assertEqual(response.get("Location"), self.reverse("core:daily")) grade = Grade.objects.get(student=student, graded_work=graded_work) self.assertEqual(grade.score, 100)
def test_complete_daily(self): today = timezone.now().date() user = self.make_user() student = StudentFactory(school=user.school) school_year = SchoolYearFactory(school=user.school) grade_level = GradeLevelFactory(school_year=school_year) course = CourseFactory(grade_level=grade_level) task = CourseTaskFactory(course=course) data = { "completed_date": "{:%Y-%m-%d}".format(today), f"task-{student.id}-{task.id}": "on", } with self.login(user): self.post("core:daily", data=data) self.assertTrue( Coursework.objects.filter(student=student, course_task=task, completed_date=today).exists())
def test_save_new_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) 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_student_can_create_coursework(self): """The student is enrolled in a course that contains the task.""" user = self.make_user() student = StudentFactory(school=user.school) grade_level = GradeLevelFactory(school_year__school=user.school) course = CourseFactory(grade_levels=[grade_level]) course_task = CourseTaskFactory(course=course) data = { "student": str(student.id), "course_task": str(course_task.id), "completed_date": str(grade_level.school_year.start_date), } form = CourseworkForm(data=data) is_valid = form.is_valid() assert not is_valid assert form.non_field_errors() == [ "The student is not enrolled in this course." ]
def test_has_surrounding_week_dates(self, timezone): """The context has the previous and next week dates.""" user = self.make_user() now = datetime.datetime(2020, 1, 26, tzinfo=pytz.utc) sunday = now.date() + relativedelta(weekday=SU(-1)) previous_sunday = sunday - datetime.timedelta(days=7) next_sunday = sunday + datetime.timedelta(days=7) timezone.localdate.return_value = now.date() SchoolYearFactory( school=user.school, start_date=now, end_date=now + datetime.timedelta(days=1), ) StudentFactory(school=user.school) with self.login(user): self.get("core:dashboard") assert self.get_context("previous_week_date") == previous_sunday assert self.get_context("next_week_date") == next_sunday
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_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_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_surrounding_dates(self, mock_timezone): wednesday = timezone.localdate() + relativedelta(weekday=WE) mock_timezone.localdate.return_value = wednesday user = self.make_user() SchoolYearFactory( school=user.school, days_of_week=SchoolYear.TUESDAY + SchoolYear.WEDNESDAY + SchoolYear.THURSDAY, ) StudentFactory(school=user.school) with self.login(user): self.get("core:daily") previous_thursday = wednesday - datetime.timedelta(days=6) self.assertContext("ereyesterday", previous_thursday) self.assertContext("yesterday", wednesday - datetime.timedelta(days=1)) self.assertContext("tomorrow", wednesday + datetime.timedelta(days=1)) next_tuesday = wednesday + datetime.timedelta(days=6) self.assertContext("overmorrow", next_tuesday)
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)