def test_no_student_forecast(self):
"""The forecaster can produce a forecast for no student."""
enrollment = EnrollmentFactory()
course = CourseFactory(grade_levels=[enrollment.grade_level])
task = CourseTaskFactory(course=course)
forecaster = Forecaster()
items = forecaster.get_items_by_task(None, course)
assert items[task]["planned_date"] == datetime.date.today()
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])
with self.login(user):
self.get_check_200(
"students:course", uuid=student.uuid, course_uuid=course.uuid
)
def test_post_other_user(self):
"""A user may not delete another user's resource."""
user = self.make_user()
course = CourseFactory()
resource = CourseResourceFactory(course=course)
with self.login(user):
response = self.get("courses:resource_delete", uuid=resource.uuid)
self.response_404(response)
def test_no_tasks_to_forecast(self):
"""No tasks returns a last date of None."""
enrollment = EnrollmentFactory()
student = enrollment.student
course = CourseFactory(grade_levels=[enrollment.grade_level])
forecaster = Forecaster()
last_date = forecaster.get_last_forecast_date(student, course)
assert last_date is None
def test_get(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
with self.login(user):
self.get_check_200("courses:resource_create", pk=course.id)
assert self.get_context("create")
assert self.get_context("course") == course
def test_get_courses(self):
enrollment = EnrollmentFactory()
student = enrollment.student
school_year = enrollment.grade_level.school_year
GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_level=enrollment.grade_level)
courses = student.get_courses(school_year)
self.assertEqual(list(courses), [course])
def test_get(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
with self.login(user):
self.get_check_200("courses:detail", uuid=course.uuid)
assert list(self.get_context("grade_levels")) == [grade_level]
assert self.get_context("school_year") == grade_level.school_year
def test_course_filter(self):
"""The report can filter to an individual course."""
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school)
student = enrollment.student
course_1 = CourseFactory(grade_levels=[enrollment.grade_level])
course_2 = CourseFactory(grade_levels=[enrollment.grade_level])
GradeFactory(student=student,
graded_work__course_task__course=course_1)
GradeFactory(student=student,
graded_work__course_task__course=course_2)
url = self.reverse("reports:progress", pk=enrollment.id)
url += f"?course={course_1.id}"
with self.login(user):
self.get_check_200(url)
assert len(self.get_context("courses")) == 1
def test_start_after_end(self):
school_year = SchoolYearFactory()
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_levels=[grade_level])
start_date = datetime.date(2020, 5, 7)
end_date = datetime.date(2020, 5, 5)
count = school_year.get_task_count_in_range(course, start_date, end_date)
assert count == 1
def test_has_course(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
task = CourseTaskFactory(course=course)
with self.login(user):
self.get("courses:task_edit", uuid=task.uuid)
self.assertContext("course", task.course)
def test_only_users_course(self):
"""The course must belong to the user for the grade level."""
user = self.make_user()
GradeLevelFactory(school_year__school=user.school)
CourseFactory()
with self.login(user):
self.get_check_200("core:start-course")
assert self.get_context("course") is None
def test_ok(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
with self.login(user):
self.get_check_200("core:start-course")
assert self.get_context("grade_level") == grade_level
assert self.get_context("course") == course
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_post_other_user(self):
user = self.make_user()
course = CourseFactory()
task = CourseTaskFactory(course=course)
with self.login(user):
response = self.get("courses:task_delete",
uuid=course.uuid,
task_uuid=task.uuid)
self.response_404(response)
def test_get(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level],
default_task_duration=42)
with self.login(user):
self.get_check_200("courses:task_create", uuid=course.uuid)
form = self.get_context("form")
assert form.initial["duration"] == course.default_task_duration
def test_course_copy_only_user_courses(self):
"""A user cannot copy another user's course."""
user = self.make_user()
SchoolYearFactory(school=user.school)
course_to_copy = CourseFactory()
with self.login(user):
self.get_check_200("courses:create",
data={"copy_from": str(course_to_copy.uuid)})
assert self.get_context("course_to_copy") is None
def test_other_user(self):
user = self.make_user()
student = StudentFactory()
course = CourseFactory()
with self.login(user):
response = self.get("students:course",
uuid=student.uuid,
course_uuid=course.uuid)
self.response_404(response)
def test_delete_other_user(self):
"""Another user cannot delete a user's task."""
user = self.make_user()
course = CourseFactory()
task = CourseTaskFactory(course=course)
with self.login(user):
response = self.delete("courses:task_hx_delete", pk=task.id)
assert CourseTask.objects.count() == 1
self.response_404(response)
def test_enrolled_students(self):
"""The enrolled students of the course are in the context."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
enrollment = EnrollmentFactory(grade_level=grade_level)
with self.login(user):
self.get_check_200("courses:detail", pk=course.id)
assert self.get_context("enrolled_students") == [enrollment.student]
def test_delete(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
task = CourseTaskFactory(course=course)
with self.login(user):
response = self.delete("courses:task_hx_delete", uuid=task.uuid)
assert CourseTask.objects.count() == 0
self.response_200(response)
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])
with self.login(user):
self.get_check_200("students:course", pk=student.id, course_id=course.id)
assert self.get_context("student") == student
assert self.get_context("course") == course
def test_other_course(self):
"""A user may not get bulk create forms for another user's course."""
user = self.make_user()
course = CourseFactory()
with self.login(user):
response = self.get(
"courses:task_create_bulk_hx", pk=course.id, last_form_number=2
)
assert response.status_code == 404
def test_grade_level_name_with_task(self):
"""Any grade level specific task has the grade level's name next to it."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
CourseTaskFactory(course=course, grade_level=grade_level)
with self.login(user):
self.get("courses:detail", pk=course.id)
self.assertResponseContains(grade_level.name)
def test_has_course(self):
user = self.make_user()
student = StudentFactory(school=user.school)
course = CourseFactory(grade_level__school_year__school=user.school)
with self.login(user):
self.get_check_200("students:course",
uuid=student.uuid,
course_uuid=course.uuid)
self.assertContext("course", course)
def test_post(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
data = {
"name": "New course name",
"wednesday": "on",
"friday": "on",
"grade_levels": str(grade_level.id),
"default_task_duration": 45,
"is_active": False,
}
with self.login(user):
self.post("courses:edit", pk=course.id, data=data)
course.refresh_from_db()
assert course.name == "New course name"
assert course.days_of_week == Course.WEDNESDAY + Course.FRIDAY
assert not course.is_active
def test_next_course_day_course_not_running(self):
"""When the course isn't running, a next course day is returned."""
school_year = SchoolYearFactory(days_of_week=SchoolYear.ALL_DAYS)
grade_level = GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_levels=[grade_level],
days_of_week=SchoolYear.NO_DAYS)
next_course_day = school_year.get_next_course_day(
course, school_year.start_date, student=None)
assert next_course_day == school_year.start_date
def test_only_users_course_task(self):
"""The task must belong to the user."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
CourseFactory(grade_levels=[grade_level])
CourseTaskFactory()
with self.login(user):
self.get_check_200("core:start-course-task")
assert self.get_context("task") is None
def test_has_grade_levels(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
other_grade_level = GradeLevelFactory(school_year=grade_level.school_year)
course = CourseFactory(grade_levels=[grade_level])
with self.login(user):
self.get("courses:task_create", uuid=course.uuid)
grade_levels = set(self.get_context("grade_levels"))
assert grade_levels == {grade_level, other_grade_level}
def test_get_courses(self):
enrollment = EnrollmentFactory()
student = enrollment.student
school_year = enrollment.grade_level.school_year
GradeLevelFactory(school_year=school_year)
course = CourseFactory()
course.grade_levels.add(enrollment.grade_level)
courses = student.get_courses(school_year)
assert list(courses) == [course]
def test_only_users_courses(self):
"""A user may not assign a task to another user's course."""
user = self.make_user()
course = CourseFactory()
data = {"course": str(course.id), "description": "A new task", "duration": "30"}
form = CourseTaskForm(user=user, data=data)
is_valid = form.is_valid()
assert not is_valid
assert "You may not add a task to another" in form.non_field_errors()[0]
