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_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 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 courses():
"""Fixture for a set of Courses in the database"""
return CourseFactory.create_batch(3)
