def test_program_courses(self): """ Test ProgramSerializer with multiple courses """ CourseFactory.create_batch(5, program=self.program) data = ProgramSerializer(self.program, context=self.context).data assert data == { 'id': self.program.id, 'title': self.program.title, 'programpage_url': None, 'enrolled': False, 'total_courses': 5, }
def test_program_page(browser, base_test_data, logged_in_student): """ Test viewing the program page """ courses = list(base_test_data.program.course_set.all()) + \ CourseFactory.create_batch(2, program=base_test_data.program) page = ProgramPageFactory.create(program=base_test_data.program, title="A Program Title") faculty = FacultyFactory.create_batch(3, program_page=page) info_links = InfoLinksFactory.create_batch(3, program_page=page) semester_dates = SemesterDateFactory.create_batch(3, program_page=page) program_courses = ProgramCourseFactory.create_batch( len(courses), program_page=page, course=Iterator(courses)) browser.get("/a-program-title/") faculty_elements = browser.driver.find_elements_by_css_selector( ".faculty-tile") assert len(faculty) == len(faculty_elements) info_elements = browser.driver.find_elements_by_css_selector( ".program-contact-link") assert len(info_links) == len(info_elements) semester_elements = browser.driver.find_elements_by_css_selector( ".semester-date") assert len(semester_dates) == len(semester_elements) program_course_elements = browser.driver.find_elements_by_css_selector( ".program-course .title") assert len(program_courses) == len(program_course_elements)
def test_program_page(browser, base_test_data, logged_in_student): """ Test viewing the program page """ courses = list(base_test_data.program.course_set.all()) + \ CourseFactory.create_batch(2, program=base_test_data.program) page = ProgramPageFactory.create(program=base_test_data.program, title="A Program Title") faculty = FacultyFactory.create_batch(3, program_page=page) info_links = InfoLinksFactory.create_batch(3, program_page=page) semester_dates = SemesterDateFactory.create_batch(3, program_page=page) program_courses = ProgramCourseFactory.create_batch( len(courses), program_page=page, course=Iterator(courses) ) browser.get("/a-program-title/") faculty_elements = browser.driver.find_elements_by_css_selector(".faculty-tile") assert len(faculty) == len(faculty_elements) info_elements = browser.driver.find_elements_by_css_selector(".program-contact-link") assert len(info_links) == len(info_elements) semester_elements = browser.driver.find_elements_by_css_selector(".semester-date") assert len(semester_dates) == len(semester_elements) program_course_elements = browser.driver.find_elements_by_css_selector(".program-course .title") assert len(program_courses) == len(program_course_elements)
def test_serialize_basket_product_version_program(mock_context): """Test ProductVersion serialization for a Program""" program = ProgramFactory.create() courses = CourseFactory.create_batch(3, program=program) product_version = ProductVersionFactory.create( product=ProductFactory(content_object=program) ) data = FullProductVersionSerializer( instance=product_version, context=mock_context ).data assert data == { "id": product_version.id, "description": product_version.description, "content_title": product_version.product.content_object.title, "price": str(round_half_up(product_version.price)), "type": product_version.product.content_type.model, "courses": [ CourseSerializer(instance=course, context=mock_context).data for course in courses ], "thumbnail_url": program.catalog_image_url, "object_id": product_version.product.object_id, "product_id": product_version.product.id, "readable_id": get_readable_id(product_version.product.content_object), "run_tag": None, "created_on": product_version.created_on.strftime(datetime_millis_format), "start_date": product_version.product.content_object.next_run_date.isoformat() if product_version.product.content_object.next_run_date else None, }
def test_program_page_serializer(self): """ Test program page serializer """ page = ProgramPageFactory.create() courses = CourseFactory.create_batch(6, program=page.program) faculty = FacultyFactory.create_batch(3, program_page=page) elective_set = ElectivesSet.objects.create(program=page.program, required_number=2, title="Elective") # Add 3 courses to elective set - For required 2 of 3 scenario for elective_course in courses[:3]: ElectiveCourse.objects.create(electives_set=elective_set, course=elective_course) data = ProgramPageSerializer(page).data data['faculty'] = sorted(data['faculty'], key=lambda member: member['name']) assert data == { "id": page.program.id, "title": page.title, "slug": ProgramPageSerializer().get_slug(page), "faculty": FacultySerializer(sorted(faculty, key=lambda member: member.name), many=True).data, # Only core courses (Not associated with electives) "courses": CourseSerializer(courses[3:], many=True).data, "electives_sets": ElectivesSetSerializer([elective_set], many=True).data, }
def test_catalog_program_serializer(has_page, has_thumbnail): """Tests that the catalog serializer returns a correct data structure""" page = ProgramPageFactory.create( has_thumbnail=has_thumbnail) if has_page else None program = page.program if page else ProgramFactory.create() courses = CourseFactory.create_batch(3, program=program) for course in courses: CourseRunFactory.create_batch(2, course=course) faculty_name = "faculty" if has_page: ProgramFaculty.objects.create( program_page=page, name=faculty_name, ) serialized = CatalogProgramSerializer(program).data # coerce OrderedDict objects to dict serialized = { **serialized, "courses": [{ **course, "course_runs": [dict(run) for run in course["course_runs"]] } for course in serialized["courses"]] } assert serialized == { "id": program.id, "title": program.title, "programpage_url": page.get_full_url() if has_page else None, "thumbnail_url": (page.thumbnail_image.get_rendition('fill-300x186').url if has_page and has_thumbnail else None), "courses": [{ "id": course.id, "edx_key": course.edx_key, "position_in_program": course.position_in_program, "course_runs": [{ "id": course_run.id, "edx_course_key": course_run.edx_course_key, } for course_run in course.courserun_set.all()] } for course in courses], 'topics': [{ 'name': topic.name } for topic in program.topics.iterator()], "instructors": [{ "name": faculty_name }] if has_page else [], "start_date": courses[0].first_unexpired_run().start_date, "enrollment_start": courses[0].first_unexpired_run().enrollment_start, "end_date": courses[-1].courserun_set.last().end_date, "total_price": str(program.price * program.num_required_courses), }
def test_defer_enrollment_validation(mocker, user): """ defer_enrollment should raise an exception if the 'from' or 'to' course runs are invalid """ courses = CourseFactory.create_batch(2) enrollments = CourseRunEnrollmentFactory.create_batch( 3, user=user, active=factory.Iterator([False, True, True]), run__course=factory.Iterator([courses[0], courses[0], courses[1]]), ) unenrollable_run = CourseRunFactory.create(enrollment_end=now_in_utc() - timedelta(days=1)) patched_create_enrollments = mocker.patch( "courses.api.create_run_enrollments", return_value=([], False)) mocker.patch("courses.api.deactivate_run_enrollment", return_value=[]) with pytest.raises(ValidationError): # Deferring to the same course run should raise a validation error defer_enrollment(user, enrollments[0].run.courseware_id, enrollments[0].run.courseware_id) patched_create_enrollments.assert_not_called() with pytest.raises(ValidationError): # Deferring to a course run that is outside of its enrollment period should raise a validation error defer_enrollment(user, enrollments[0].run.courseware_id, unenrollable_run.courseware_id) patched_create_enrollments.assert_not_called() with pytest.raises(ValidationError): # Deferring from an inactive enrollment should raise a validation error defer_enrollment(user, enrollments[0].run.courseware_id, enrollments[1].run.courseware_id) patched_create_enrollments.assert_not_called() with pytest.raises(ValidationError): # Deferring to a course run in a different course should raise a validation error defer_enrollment(user, enrollments[1].run.courseware_id, enrollments[2].run.courseware_id) patched_create_enrollments.assert_not_called() # The last two cases should not raise an exception if the 'force' flag is set to True defer_enrollment( user, enrollments[0].run.courseware_id, enrollments[1].run.courseware_id, force=True, ) assert patched_create_enrollments.call_count == 1 defer_enrollment( user, enrollments[1].run.courseware_id, enrollments[2].run.courseware_id, force=True, ) assert patched_create_enrollments.call_count == 2
def test_lists_catalog(self): """Course Runs should show up""" program = ProgramFactory.create(live=True) for course in CourseFactory.create_batch(3, program=program): CourseRunFactory.create_batch(2, course=course) resp = self.client.get(reverse('catalog-list')) assert len(resp.json()) == 1 data = CatalogProgramSerializer(program).data assert_drf_json_equal([data], resp.json())
def test_elective_set(self): """ Make sure course that elective set serializer works correctly """ courses = CourseFactory.create_batch(3) elective_set = ElectivesSet.objects.create(program=courses[0].program, title="Elective", required_number=2) for course in courses: ElectiveCourse.objects.create(course=course, electives_set=elective_set) data = ElectivesSetSerializer(elective_set).data assert data == { "required_number": elective_set.required_number, "title": elective_set.title, "courses": CourseSerializer(courses, many=True).data, }
def test_program_page_serializer(self): """ Test program page serializer """ page = ProgramPageFactory.create() courses = CourseFactory.create_batch(3, program=page.program) faculty = FacultyFactory.create_batch(3, program_page=page) data = ProgramPageSerializer(page).data data['faculty'] = sorted(data['faculty'], key=lambda member: member['name']) assert data == { "id": page.program.id, "title": page.title, "slug": ProgramPageSerializer().get_slug(page), "faculty": FacultySerializer(sorted(faculty, key=lambda member: member.name), many=True).data, "courses": CourseSerializer(courses, many=True).data, }
def test_semester_serialization(self): """ Tests that each course run has a string semester value as part of its serialization """ num_courses = 5 courses = CourseFactory.create_batch(num_courses, program=self.program) course_runs = [CourseRunFactory.create(course=course) for course in courses] for course_run in course_runs: CachedEnrollmentFactory.create(user=self.user, course_run=course_run, verified=True) with patch( 'dashboard.serializers.get_year_season_from_course_run', autospec=True, return_value=(2017, 'Spring') ) as get_year_season_patch: serialized_program_user = UserProgramSearchSerializer.serialize(self.program_enrollment) assert len(serialized_program_user['courses']) == num_courses assert all( semester_enrollment['semester'] == '2017 - Spring' for semester_enrollment in serialized_program_user['course_runs'] ) # multiply by two while serialize_enrollments has semester assert get_year_season_patch.call_count == num_courses*2
def test_semester_serialization(self): """ Tests that each course run has a string semester value as part of its serialization """ num_courses = 5 courses = CourseFactory.create_batch(num_courses, program=self.program) course_runs = [ CourseRunFactory.create(course=course) for course in courses ] for course_run in course_runs: CachedEnrollmentFactory.create(user=self.user, course_run=course_run, verified=True) with patch('dashboard.serializers.get_year_season_from_course_run', autospec=True, return_value=(2017, 'Spring')) as get_year_season_patch: serialized_program_user = UserProgramSearchSerializer.serialize( self.program_enrollment) assert len(serialized_program_user['courses']) == num_courses assert all( semester_enrollment['semester'] == '2017 - Spring' for semester_enrollment in serialized_program_user['course_runs']) # multiply by two while serialize_enrollments has semester assert get_year_season_patch.call_count == num_courses * 2
def courses(): """Fixture for a set of Courses in the database""" return CourseFactory.create_batch(3)