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)
