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]