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_user_access_their_school_years(self):
"""The user can only access their school years."""
user = self.make_user()
grade_level = GradeLevelFactory()
with self.login(user):
response = self.get("students:enrollment_create",
school_year_id=grade_level.school_year.id)
self.response_404(response)
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_post(self):
"""A user can update a grade level for their school year."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
data = {
"school_year": str(grade_level.school_year.id),
"name": "12th Grade"
}
with self.login(user):
response = self.post("schools:grade_level_edit",
pk=grade_level.id,
data=data)
grade_level.refresh_from_db()
assert grade_level.name == "12th Grade"
self.response_302(response)
assert response.get("Location") == self.reverse(
"schools:school_year_detail", pk=grade_level.school_year.id)
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(self):
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
resource = CourseResourceFactory(course__grade_levels=[grade_level])
with self.login(user):
self.get_check_200("courses:resource_edit", uuid=resource.uuid)
assert not self.get_context("create")
assert self.get_context("course") == resource.course
def test_has_grade_level(self):
"""A grade level put in the querystring is available as context."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school__admin=user)
with self.login(user):
self.get_check_200("courses:create",
data={"grade_level": str(grade_level.uuid)})
assert self.get_context("grade_level") == grade_level
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_only_users_grade_levels(self):
"""A user can only view their own grade levels."""
user = self.make_user()
grade_level = GradeLevelFactory()
with self.login(user):
response = self.get("schools:grade_level_detail",
pk=grade_level.id)
self.response_404(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",
uuid=student.uuid,
course_uuid=course.uuid)
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_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_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_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_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_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_not_other_grade_level(self):
"""A different user's grade level cannot be in the context."""
user = self.make_user()
SchoolYearFactory(school__admin=user)
grade_level = GradeLevelFactory()
with self.login(user):
self.get_check_200("courses:create",
data={"grade_level": str(grade_level.uuid)})
assert self.get_context("grade_level") is None
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_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_no_students_with_task(self):
"""Even when no student exists, the start banner may appear."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
CourseTaskFactory(course__grade_levels=[grade_level])
with self.login(user):
self.get_check_200("core:daily")
assert not self.get_context("has_students")
assert self.get_context("has_tasks")
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_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_schedules(self, timezone):
now = datetime.datetime(2020, 1, 24, tzinfo=pytz.utc)
friday = now.date()
timezone.now.return_value = now
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_2 = 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_2
},
{
"course": course_3
},
{
"course": course_4,
"task": None
},
],
}
self.assertContext("schedules", [expected_schedule])
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_other_school_year(self):
"""A user may not edit the order of another school year's grade levels."""
user = self.make_user()
school_year = SchoolYearFactory()
first_grade_level = GradeLevelFactory(school_year=school_year)
with self.login(user):
response = self.post("schools:grade_level_up",
pk=first_grade_level.id)
self.response_404(response)
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_get_tasks_enrolled(self):
"""A student enrolled in a course gets all the correct tasks for that course."""
enrollment = EnrollmentFactory()
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())
course_tasks = enrollment.student.get_tasks_for(course)
assert list(course_tasks) == [general_task, grade_level_task]
def test_has_previous_task(self):
"""A previous task is in the context when it exists."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
previous_task = CourseTaskFactory(course=course)
task = CourseTaskFactory(course=course)
with self.login(user):
self.get("courses:task_edit", pk=task.id)
assert self.get_context("previous_task") == previous_task
def test_no_student_planned_date(self):
"""When no student is enrolled, the tasks have a planned completion date."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
CourseTaskFactory(course=course)
with self.login(user):
self.get_check_200("courses:detail", pk=course.id)
planned_date = self.get_context("task_details")[0]["planned_date"]
assert planned_date == datetime.date.today()
def test_task_complete_no_student(self):
"""When there are no students, a task defaults to incomplete."""
user = self.make_user()
grade_level = GradeLevelFactory(school_year__school=user.school)
course = CourseFactory(grade_levels=[grade_level])
CourseTaskFactory(course=course)
with self.login(user):
self.get_check_200("courses:detail", pk=course.id)
detail = self.get_context("task_details")[0]
assert not detail["complete"]
