Skip to content

C
course-discovery
Commit 3dd051a1 by Renzo Lucioni Committed by Clinton Blackburn
Options

Roll back attempted program list optimizations

parent 54feb857
Showing with 438 additions and 310 deletions
course_discovery/apps/api/serializers.py
# pylint: disable=abstract-method
import datetime
import json
from urllib.parse import urlencode
import pytz
from django.contrib.auth import get_user_model
from django.utils.translation import ugettext_lazy as _
from drf_haystack.serializers import HaystackSerializer, HaystackFacetSerializer
......@@ -83,7 +85,7 @@ PREFETCH_FIELDS = {
}
SELECT_RELATED_FIELDS = {
'course': ['level_type', 'video', 'partner', ],
'course': ['level_type', 'video', ],
'course_run': ['course', 'language', 'video', ],
'program': ['type', 'video', 'partner', ],
}
......@@ -225,21 +227,13 @@ class SeatSerializer(serializers.ModelSerializer):
fields = ('type', 'price', 'currency', 'upgrade_deadline', 'credit_provider', 'credit_hours',)
class MinimalOrganizationSerializer(serializers.ModelSerializer):
class Meta:
model = Organization
fields = ('uuid', 'key', 'name',)
class OrganizationSerializer(TaggitSerializer, MinimalOrganizationSerializer):
class OrganizationSerializer(TaggitSerializer, serializers.ModelSerializer):
"""Serializer for the ``Organization`` model."""
tags = TagListSerializerField()
class Meta(MinimalOrganizationSerializer.Meta):
class Meta(object):
model = Organization
fields = MinimalOrganizationSerializer.Meta.fields + (
'description', 'homepage_url', 'tags', 'logo_image_url', 'marketing_url',
)
fields = ('key', 'name', 'description', 'homepage_url', 'tags', 'logo_image_url', 'marketing_url')
class CatalogSerializer(serializers.ModelSerializer):
......@@ -277,13 +271,7 @@ class NestedProgramSerializer(serializers.ModelSerializer):
read_only_fields = ('uuid', 'marketing_url',)
class MinimalCourseRunSerializer(TimestampModelSerializer):
class Meta:
model = CourseRun
fields = ('key', 'uuid', 'title',)
class CourseRunSerializer(MinimalCourseRunSerializer):
class CourseRunSerializer(TimestampModelSerializer):
"""Serializer for the ``CourseRun`` model."""
course = serializers.SlugRelatedField(read_only=True, slug_field='key')
content_language = serializers.SlugRelatedField(
......@@ -299,13 +287,13 @@ class CourseRunSerializer(MinimalCourseRunSerializer):
marketing_url = serializers.SerializerMethodField()
level_type = serializers.SlugRelatedField(read_only=True, slug_field='name')
class Meta(MinimalCourseRunSerializer.Meta):
class Meta(object):
model = CourseRun
fields = MinimalCourseRunSerializer.Meta.fields + (
'course', 'short_description', 'full_description', 'start', 'end', 'enrollment_start', 'enrollment_end',
'announcement', 'image', 'video', 'seats', 'content_language', 'transcript_languages', 'instructors',
'staff', 'pacing_type', 'min_effort', 'max_effort', 'modified', 'marketing_url', 'level_type',
'availability',
fields = (
'course', 'key', 'title', 'short_description', 'full_description', 'start', 'end',
'enrollment_start', 'enrollment_end', 'announcement', 'image', 'video', 'seats',
'content_language', 'transcript_languages', 'instructors', 'staff',
'pacing_type', 'min_effort', 'max_effort', 'modified', 'marketing_url', 'level_type', 'availability',
)
def get_marketing_url(self, obj):
......@@ -332,16 +320,7 @@ class ContainedCourseRunsSerializer(serializers.Serializer):
)
class MinimalCourseSerializer(TimestampModelSerializer):
course_runs = MinimalCourseRunSerializer(many=True)
owners = MinimalOrganizationSerializer(many=True, source='authoring_organizations')
class Meta:
model = Course
fields = ('key', 'uuid', 'title', 'course_runs', 'owners',)
class CourseSerializer(MinimalCourseSerializer):
class CourseSerializer(TimestampModelSerializer):
"""Serializer for the ``Course`` model."""
level_type = serializers.SlugRelatedField(read_only=True, slug_field='name')
subjects = SubjectSerializer(many=True)
......@@ -354,11 +333,12 @@ class CourseSerializer(MinimalCourseSerializer):
course_runs = CourseRunSerializer(many=True)
marketing_url = serializers.SerializerMethodField()
class Meta(MinimalCourseSerializer.Meta):
class Meta(object):
model = Course
fields = MinimalCourseSerializer.Meta.fields + (
'short_description', 'full_description', 'level_type', 'subjects', 'prerequisites',
'expected_learning_items', 'image', 'video', 'sponsors', 'modified', 'marketing_url',
fields = (
'key', 'title', 'short_description', 'full_description', 'level_type', 'subjects', 'prerequisites',
'expected_learning_items', 'image', 'video', 'owners', 'sponsors', 'modified', 'course_runs',
'marketing_url',
)
def get_marketing_url(self, obj):
......@@ -390,55 +370,29 @@ class ContainedCoursesSerializer(serializers.Serializer):
)
class ProgramCourseSerializer(MinimalCourseSerializer):
class ProgramCourseSerializer(CourseSerializer):
"""Serializer used to filter out excluded course runs in a course associated with the program"""
course_runs = serializers.SerializerMethodField()
def get_course_runs(self, course):
program = self.context['program']
course_runs = list(course.course_runs.all())
excluded_course_runs = list(program.excluded_course_runs.all())
course_runs = [course_run for course_run in course_runs if course_run not in excluded_course_runs]
course_runs = self.context['course_runs']
course_runs = [course_run for course_run in course_runs if course_run.course == course]
if self.context.get('published_course_runs_only'):
course_runs = [course_run for course_run in course_runs if course_run.status == CourseRunStatus.Published]
return MinimalCourseRunSerializer(
return CourseRunSerializer(
course_runs,
many=True,
context={'request': self.context.get('request')}
).data
class MinimalProgramSerializer(serializers.ModelSerializer):
authoring_organizations = MinimalOrganizationSerializer(many=True)
banner_image = StdImageSerializerField()
class ProgramSerializer(serializers.ModelSerializer):
courses = serializers.SerializerMethodField()
authoring_organizations = OrganizationSerializer(many=True)
type = serializers.SlugRelatedField(slug_field='name', queryset=ProgramType.objects.all())
def get_courses(self, program):
course_serializer = ProgramCourseSerializer(
program.courses.all(),
many=True,
context={
'request': self.context.get('request'),
'program': program,
'published_course_runs_only': self.context.get('published_course_runs_only'),
}
)
return course_serializer.data
class Meta:
model = Program
fields = (
'uuid', 'title', 'subtitle', 'type', 'status', 'marketing_slug', 'marketing_url', 'banner_image', 'courses',
'authoring_organizations', 'card_image_url',
)
read_only_fields = ('uuid', 'marketing_url', 'banner_image')
class ProgramSerializer(MinimalProgramSerializer):
banner_image = StdImageSerializerField()
video = VideoSerializer()
expected_learning_items = serializers.SlugRelatedField(many=True, read_only=True, slug_field='value')
faq = FAQSerializer(many=True)
......@@ -457,14 +411,90 @@ class ProgramSerializer(MinimalProgramSerializer):
subjects = SubjectSerializer(many=True)
staff = PersonSerializer(many=True)
class Meta(MinimalProgramSerializer.Meta):
def get_courses(self, program):
courses, course_runs = self.sort_courses(program)
course_serializer = ProgramCourseSerializer(
courses,
many=True,
context={
'request': self.context.get('request'),
'program': program,
'published_course_runs_only': self.context.get('published_course_runs_only'),
'course_runs': course_runs,
}
)
return course_serializer.data
def sort_courses(self, program):
"""
Sorting by enrollment start then by course start yields a list ordered by course start, with
ties broken by enrollment start. This works because Python sorting is stable: two objects with
equal keys appear in the same order in sorted output as they appear in the input.
Courses are only created if there's at least one course run belonging to that course, so
course_runs should never be empty. If it is, key functions in this method attempting to find the
min of an empty sequence will raise a ValueError.
"""
course_runs = program.course_runs.select_related(*SELECT_RELATED_FIELDS['course_run'])
course_runs = course_runs.prefetch_related(*PREFETCH_FIELDS['course_run'])
course_runs = list(course_runs)
def min_run_enrollment_start(course):
# Enrollment starts may be empty. When this is the case, we make the same assumption as
# the LMS: no enrollment_start is equivalent to (offset-aware) datetime.datetime.min.
min_datetime = datetime.datetime.min.replace(tzinfo=pytz.UTC)
# Course runs excluded from the program are excluded here, too.
#
# If this becomes a candidate for optimization in the future, be careful sorting null values
# in the database. PostgreSQL and MySQL sort null values as if they are higher than non-null
# values, while SQLite does the opposite.
#
# For more, refer to https://docs.djangoproject.com/en/1.10/ref/models/querysets/#latest.
_course_runs = [course_run for course_run in course_runs if course_run.course == course]
# Return early if we have no course runs since min() will fail.
if not _course_runs:
return min_datetime
run = min(_course_runs, key=lambda run: run.enrollment_start or min_datetime)
return run.enrollment_start or min_datetime
def min_run_start(course):
# Course starts may be empty. Since this means the course can't be started, missing course
# start date is equivalent to (offset-aware) datetime.datetime.max.
max_datetime = datetime.datetime.max.replace(tzinfo=pytz.UTC)
_course_runs = [course_run for course_run in course_runs if course_run.course == course]
# Return early if we have no course runs since min() will fail.
if not _course_runs:
return max_datetime
run = min(_course_runs, key=lambda run: run.start or max_datetime)
return run.start or max_datetime
courses = list(program.courses.all())
courses.sort(key=min_run_enrollment_start)
courses.sort(key=min_run_start)
return courses, course_runs
class Meta:
model = Program
fields = MinimalProgramSerializer.Meta.fields + (
'overview', 'weeks_to_complete', 'min_hours_effort_per_week', 'max_hours_effort_per_week', 'video',
fields = (
'uuid', 'title', 'subtitle', 'type', 'status', 'marketing_slug', 'marketing_url', 'courses',
'overview', 'weeks_to_complete', 'min_hours_effort_per_week', 'max_hours_effort_per_week',
'authoring_organizations', 'banner_image', 'banner_image_url', 'card_image_url', 'video',
'expected_learning_items', 'faq', 'credit_backing_organizations', 'corporate_endorsements',
'job_outlook_items', 'individual_endorsements', 'languages', 'transcript_languages', 'subjects',
'price_ranges', 'staff', 'credit_redemption_overview',
'price_ranges', 'staff', 'credit_redemption_overview'
)
read_only_fields = ('uuid', 'marketing_url', 'banner_image')
class AffiliateWindowSerializer(serializers.ModelSerializer):
......
course_discovery/apps/api/tests/test_fields.py
from django.test import TestCase
from course_discovery.apps.api.fields import ImageField, StdImageSerializerField
from course_discovery.apps.api.tests.test_serializers import make_request
from course_discovery.apps.core.tests.helpers import make_image_file
from course_discovery.apps.course_metadata.tests.factories import ProgramFactory
from course_discovery.apps.api.fields import ImageField
class ImageFieldTests(TestCase):
......@@ -16,27 +13,3 @@ class ImageFieldTests(TestCase):
'width': None
}
self.assertEqual(ImageField().to_representation(value), expected)
# pylint: disable=no-member
class StdImageSerializerFieldTests(TestCase):
def test_to_representation(self):
request = make_request()
# TODO Create test-only model to avoid unnecessary dependency on Program model.
program = ProgramFactory(banner_image=make_image_file('test.jpg'))
field = StdImageSerializerField()
field._context = {'request': request} # pylint: disable=protected-access
expected = {
size_key: {
'url': '{}{}'.format(
'http://testserver',
getattr(program.banner_image, size_key).url
),
'width': program.banner_image.field.variations[size_key]['width'],
'height': program.banner_image.field.variations[size_key]['height']
}
for size_key in program.banner_image.field.variations
}
self.assertDictEqual(field.to_representation(program.banner_image), expected)
course_discovery/apps/api/tests/test_serializers.py
import unittest
from datetime import datetime
from urllib.parse import urlencode
......@@ -7,16 +8,14 @@ from haystack.query import SearchQuerySet
from opaque_keys.edx.keys import CourseKey
from rest_framework.test import APIRequestFactory
from course_discovery.apps.api.fields import ImageField, StdImageSerializerField
from course_discovery.apps.api.fields import ImageField
from course_discovery.apps.api.serializers import (
CatalogSerializer, CourseRunSerializer, ContainedCoursesSerializer, ImageSerializer,
CatalogSerializer, CourseSerializer, CourseRunSerializer, ContainedCoursesSerializer, ImageSerializer,
SubjectSerializer, PrerequisiteSerializer, VideoSerializer, OrganizationSerializer, SeatSerializer,
PersonSerializer, AffiliateWindowSerializer, ContainedCourseRunsSerializer, CourseRunSearchSerializer,
ProgramSerializer, ProgramSearchSerializer, ProgramCourseSerializer, NestedProgramSerializer,
CourseRunWithProgramsSerializer, CourseWithProgramsSerializer, CorporateEndorsementSerializer,
FAQSerializer, EndorsementSerializer, PositionSerializer, FlattenedCourseRunWithCourseSerializer,
MinimalCourseSerializer, MinimalOrganizationSerializer, MinimalCourseRunSerializer, MinimalProgramSerializer,
CourseSerializer
FAQSerializer, EndorsementSerializer, PositionSerializer, FlattenedCourseRunWithCourseSerializer
)
from course_discovery.apps.catalogs.tests.factories import CatalogFactory
from course_discovery.apps.core.models import User
......@@ -32,7 +31,7 @@ from course_discovery.apps.course_metadata.tests.factories import (
from course_discovery.apps.ietf_language_tags.models import LanguageTag
# pylint:disable=no-member, test-inherits-tests
# pylint:disable=no-member
def json_date_format(datetime_obj):
return datetime.strftime(datetime_obj, "%Y-%m-%dT%H:%M:%S.%fZ")
......@@ -94,36 +93,19 @@ class CatalogSerializerTests(TestCase):
self.assertEqual(User.objects.filter(username=username).count(), 0) # pylint: disable=no-member
class MinimalCourseSerializerTests(TestCase):
serializer_class = MinimalCourseSerializer
def get_expected_data(self, course, request):
context = {'request': request}
return {
'key': course.key,
'uuid': str(course.uuid),
'title': course.title,
'course_runs': MinimalCourseRunSerializer(course.course_runs, many=True, context=context).data,
'owners': MinimalOrganizationSerializer(course.authoring_organizations, many=True, context=context).data,
}
class CourseSerializerTests(TestCase):
def test_data(self):
request = make_request()
organizations = OrganizationFactory()
course = CourseFactory(authoring_organizations=[organizations])
CourseRunFactory.create_batch(2, course=course)
serializer = self.serializer_class(course, context={'request': request})
expected = self.get_expected_data(course, request)
self.assertDictEqual(serializer.data, expected)
course = CourseFactory()
video = course.video
request = make_request()
class CourseSerializerTests(MinimalCourseSerializerTests):
serializer_class = CourseSerializer
CourseRunFactory.create_batch(3, course=course)
serializer = CourseWithProgramsSerializer(course, context={'request': request})
def get_expected_data(self, course, request):
expected = super().get_expected_data(course, request)
expected.update({
expected = {
'key': course.key,
'title': course.title,
'short_description': course.short_description,
'full_description': course.full_description,
'level_type': course.level_type.name,
......@@ -131,9 +113,11 @@ class CourseSerializerTests(MinimalCourseSerializerTests):
'prerequisites': [],
'expected_learning_items': [],
'image': ImageField().to_representation(course.card_image_url),
'video': VideoSerializer(course.video).data,
'video': VideoSerializer(video).data,
'owners': OrganizationSerializer(course.authoring_organizations, many=True).data,
'sponsors': OrganizationSerializer(course.sponsoring_organizations, many=True).data,
'modified': json_date_format(course.modified), # pylint: disable=no-member
'course_runs': CourseRunSerializer(course.course_runs, many=True, context={'request': request}).data,
'marketing_url': '{url}?{params}'.format(
url=course.marketing_url,
params=urlencode({
......@@ -141,47 +125,22 @@ class CourseSerializerTests(MinimalCourseSerializerTests):
'utm_medium': request.user.referral_tracking_id,
})
),
'course_runs': CourseRunSerializer(course.course_runs, many=True, context={'request': request}).data,
'owners': OrganizationSerializer(course.authoring_organizations, many=True).data,
})
return expected
class CourseWithProgramsSerializerTests(CourseSerializerTests): # pylint: disable=test-inherits-tests
serializer_class = CourseWithProgramsSerializer
def get_expected_data(self, course, request):
expected = super().get_expected_data(course, request)
expected.update({
'programs': NestedProgramSerializer(course.programs, many=True, context={'request': request}).data,
})
return expected
}
class MinimalCourseRunSerializerTests(TestCase):
serializer_class = MinimalCourseRunSerializer
self.assertDictEqual(serializer.data, expected)
def get_expected_data(self, course_run, request): # pylint: disable=unused-argument
return {
'key': course_run.key,
'uuid': str(course_run.uuid),
'title': course_run.title,
}
class CourseRunSerializerTests(TestCase):
def test_data(self):
request = make_request()
course_run = CourseRunFactory()
serializer = self.serializer_class(course_run, context={'request': request})
expected = self.get_expected_data(course_run, request)
self.assertDictEqual(serializer.data, expected)
class CourseRunSerializerTests(MinimalCourseRunSerializerTests): # pylint: disable=test-inherits-tests
serializer_class = CourseRunSerializer
course = course_run.course
video = course_run.video
serializer = CourseRunSerializer(course_run, context={'request': request})
ProgramFactory(courses=[course])
def get_expected_data(self, course_run, request):
expected = super().get_expected_data(course_run, request)
expected.update({
expected = {
'course': course_run.course.key,
'key': course_run.key,
'title': course_run.title, # pylint: disable=no-member
......@@ -193,7 +152,7 @@ class CourseRunSerializerTests(MinimalCourseRunSerializerTests): # pylint: disa
'enrollment_end': json_date_format(course_run.enrollment_end),
'announcement': json_date_format(course_run.announcement),
'image': ImageField().to_representation(course_run.card_image_url),
'video': VideoSerializer(course_run.video).data,
'video': VideoSerializer(video).data,
'pacing_type': course_run.pacing_type,
'content_language': course_run.language.code,
'transcript_languages': [],
......@@ -212,8 +171,9 @@ class CourseRunSerializerTests(MinimalCourseRunSerializerTests): # pylint: disa
),
'level_type': course_run.level_type.name,
'availability': course_run.availability,
})
return expected
}
self.assertDictEqual(serializer.data, expected)
class CourseRunWithProgramsSerializerTests(TestCase):
......@@ -232,6 +192,7 @@ class CourseRunWithProgramsSerializerTests(TestCase):
self.assertDictEqual(serializer.data, expected)
@unittest.skip('This test is disabled until we can determine why assertDictEqual() fails for two equivalent inputs.')
class FlattenedCourseRunWithCourseSerializerTests(TestCase): # pragma: no cover
def serialize_seats(self, course_run):
seats = {
......@@ -281,7 +242,7 @@ class FlattenedCourseRunWithCourseSerializerTests(TestCase): # pragma: no cover
def get_expected_data(self, request, course_run):
course = course_run.course
serializer_context = {'request': request}
expected = dict(CourseRunSerializer(course_run, context=serializer_context).data)
expected = CourseRunSerializer(course_run, context=serializer_context).data
expected.update({
'subjects': self.serialize_items(course.subjects.all(), 'name'),
'seats': self.serialize_seats(course_run),
......@@ -322,6 +283,7 @@ class FlattenedCourseRunWithCourseSerializerTests(TestCase): # pragma: no cover
self.assertDictEqual(serializer.data, expected)
@ddt.ddt
class ProgramCourseSerializerTests(TestCase):
def setUp(self):
super(ProgramCourseSerializerTests, self).setUp()
......@@ -336,10 +298,10 @@ class ProgramCourseSerializerTests(TestCase):
serializer = ProgramCourseSerializer(
self.course_list,
many=True,
context={'request': self.request, 'program': self.program}
context={'request': self.request, 'program': self.program, 'course_runs': self.program.course_runs}
)
expected = MinimalCourseSerializer(self.course_list, many=True, context={'request': self.request}).data
expected = CourseSerializer(self.course_list, many=True, context={'request': self.request}).data
self.assertSequenceEqual(serializer.data, expected)
......@@ -349,10 +311,10 @@ class ProgramCourseSerializerTests(TestCase):
serializer = ProgramCourseSerializer(
self.course_list,
many=True,
context={'request': self.request, 'program': self.program}
context={'request': self.request, 'program': self.program, 'course_runs': self.program.course_runs}
)
expected = MinimalCourseSerializer(self.course_list, many=True, context={'request': self.request}).data
expected = CourseSerializer(self.course_list, many=True, context={'request': self.request}).data
self.assertSequenceEqual(serializer.data, expected)
......@@ -366,138 +328,326 @@ class ProgramCourseSerializerTests(TestCase):
excluded_runs.append(course_runs[0])
program = ProgramFactory(courses=[course], excluded_course_runs=excluded_runs)
serializer_context = {'request': self.request, 'program': program}
serializer_context = {'request': self.request, 'program': program, 'course_runs': program.course_runs}
serializer = ProgramCourseSerializer(course, context=serializer_context)
expected = MinimalCourseSerializer(course, context=serializer_context).data
expected['course_runs'] = MinimalCourseRunSerializer([course_runs[1]], many=True,
context={'request': self.request}).data
expected = CourseSerializer(course, context=serializer_context).data
expected['course_runs'] = CourseRunSerializer([course_runs[1]], many=True,
context={'request': self.request}).data
self.assertDictEqual(serializer.data, expected)
def test_with_published_course_runs_only_context(self):
""" Verify setting the published_course_runs_only context value excludes unpublished course runs. """
# Create a program and course. The course should have both published and un-published course runs.
course = CourseFactory()
courses = [course]
program = ProgramFactory(courses=courses)
unpublished_course_run = CourseRunFactory(status=CourseRunStatus.Unpublished, course=course)
CourseRunFactory(status=CourseRunStatus.Published, course=course)
# We do NOT expect the results to included the unpublished data
expected = MinimalCourseSerializer(courses, many=True, context={'request': self.request}).data
expected[0]['course_runs'] = [course_run for course_run in expected[0]['course_runs'] if
course_run['uuid'] != str(unpublished_course_run.uuid)]
self.assertEqual(len(expected[0]['course_runs']), 1)
@ddt.data(
[CourseRunStatus.Unpublished, 1],
[CourseRunStatus.Unpublished, 0],
[CourseRunStatus.Published, 1],
[CourseRunStatus.Published, 0]
)
@ddt.unpack
def test_with_published_only_querystring(self, course_run_status, published_course_runs_only):
"""
Test the serializer's ability to filter out course_runs based on
"published_course_runs_only" query string
"""
expected = CourseSerializer(self.course_list, many=True, context={'request': self.request}).data
for course in self.course_list:
CourseRunFactory.create_batch(2, status=course_run_status, course=course)
serializer = ProgramCourseSerializer(
courses,
self.course_list,
many=True,
context={
'request': self.request,
'program': program,
'published_course_runs_only': True,
'program': self.program,
'published_course_runs_only': published_course_runs_only,
'course_runs': self.program.course_runs
}
)
validate_data = serializer.data
self.assertSequenceEqual(serializer.data, expected)
if not published_course_runs_only or course_run_status != CourseRunStatus.Unpublished:
expected = CourseSerializer(self.course_list, many=True, context={'request': self.request}).data
self.assertSequenceEqual(validate_data, expected)
class MinimalProgramSerializerTests(TestCase):
serializer_class = MinimalProgramSerializer
def create_program(self):
organizations = OrganizationFactory.create_batch(2)
person = PersonFactory()
courses = CourseFactory.create_batch(3)
for course in courses:
CourseRunFactory.create_batch(2, course=course, staff=[person])
class ProgramSerializerTests(TestCase):
def test_data(self):
request = make_request()
org_list = OrganizationFactory.create_batch(1)
course_list = CourseFactory.create_batch(3)
for course in course_list:
CourseRunFactory.create_batch(
3,
course=course,
enrollment_start=datetime(2014, 1, 1),
start=datetime(2014, 1, 1)
)
corporate_endorsements = CorporateEndorsementFactory.create_batch(1)
individual_endorsements = EndorsementFactory.create_batch(1)
staff = PersonFactory.create_batch(1)
job_outlook_items = JobOutlookItemFactory.create_batch(1)
expected_learning_items = ExpectedLearningItemFactory.create_batch(1)
program = ProgramFactory(
courses=courses,
authoring_organizations=organizations,
credit_backing_organizations=organizations,
corporate_endorsements=CorporateEndorsementFactory.create_batch(1),
individual_endorsements=EndorsementFactory.create_batch(1),
expected_learning_items=ExpectedLearningItemFactory.create_batch(1),
job_outlook_items=JobOutlookItemFactory.create_batch(1),
banner_image=make_image_file('test_banner.jpg'),
video=VideoFactory()
authoring_organizations=org_list,
courses=course_list,
credit_backing_organizations=org_list,
corporate_endorsements=corporate_endorsements,
individual_endorsements=individual_endorsements,
expected_learning_items=expected_learning_items,
staff=staff,
job_outlook_items=job_outlook_items,
)
return program
def get_expected_data(self, program, request):
image_field = StdImageSerializerField()
image_field._context = {'request': request} # pylint: disable=protected-access
program.banner_image = make_image_file('test_banner.jpg')
program.save()
serializer = ProgramSerializer(program, context={'request': request})
expected_banner_image_urls = {
size_key: {
'url': '{}{}'.format(
'http://testserver',
getattr(program.banner_image, size_key).url
),
'width': program.banner_image.field.variations[size_key]['width'],
'height': program.banner_image.field.variations[size_key]['height']
}
for size_key in program.banner_image.field.variations
}
return {
expected = {
'uuid': str(program.uuid),
'title': program.title,
'subtitle': program.subtitle,
'type': program.type.name,
'status': program.status,
'marketing_slug': program.marketing_slug,
'marketing_url': program.marketing_url,
'banner_image': image_field.to_representation(program.banner_image),
'courses': ProgramCourseSerializer(program.courses, many=True,
context={'request': request, 'program': program}).data,
'authoring_organizations': MinimalOrganizationSerializer(program.authoring_organizations, many=True).data,
'card_image_url': program.card_image_url,
'banner_image_url': program.banner_image_url,
'video': None,
'banner_image': expected_banner_image_urls,
'authoring_organizations': OrganizationSerializer(program.authoring_organizations, many=True).data,
'credit_redemption_overview': program.credit_redemption_overview,
'courses': ProgramCourseSerializer(
program.courses,
many=True,
context={'request': request, 'program': program, 'course_runs': program.course_runs}
).data,
'corporate_endorsements': CorporateEndorsementSerializer(program.corporate_endorsements, many=True).data,
'credit_backing_organizations': OrganizationSerializer(
program.credit_backing_organizations,
many=True
).data,
'expected_learning_items': [item.value for item in program.expected_learning_items.all()],
'faq': FAQSerializer(program.faq, many=True).data,
'individual_endorsements': EndorsementSerializer(program.individual_endorsements, many=True).data,
'staff': PersonSerializer(program.staff, many=True).data,
'job_outlook_items': [item.value for item in program.job_outlook_items.all()],
'languages': [serialize_language_to_code(l) for l in program.languages],
'weeks_to_complete': program.weeks_to_complete,
'max_hours_effort_per_week': None,
'min_hours_effort_per_week': None,
'overview': None,
'price_ranges': [],
'status': program.status,
'subjects': [],
'transcript_languages': [],
}
def test_data(self):
request = make_request()
program = self.create_program()
serializer = self.serializer_class(program, context={'request': request})
expected = self.get_expected_data(program, request)
self.assertDictEqual(serializer.data, expected)
def test_with_exclusions(self):
"""
Verify we can specify program excluded_course_runs and the serializers will
render the course_runs with exclusions
"""
request = make_request()
org_list = OrganizationFactory.create_batch(1)
course_list = CourseFactory.create_batch(4)
excluded_runs = []
for course in course_list:
course_runs = CourseRunFactory.create_batch(
3,
course=course,
enrollment_start=datetime(2014, 1, 1),
start=datetime(2014, 1, 1)
)
excluded_runs.append(course_runs[0])
class ProgramSerializerTests(MinimalProgramSerializerTests): # pylint: disable=test-inherits-tests
serializer_class = ProgramSerializer
program = ProgramFactory(
authoring_organizations=org_list,
courses=course_list,
excluded_course_runs=excluded_runs
)
serializer = ProgramSerializer(program, context={'request': request})
def get_expected_data(self, program, request):
expected = super().get_expected_data(program, request)
expected.update({
expected = {
'uuid': str(program.uuid),
'title': program.title,
'subtitle': program.subtitle,
'type': program.type.name,
'marketing_slug': program.marketing_slug,
'marketing_url': program.marketing_url,
'video': VideoSerializer(program.video).data,
'card_image_url': program.card_image_url,
'banner_image': {},
'banner_image_url': program.banner_image_url,
'video': None,
'authoring_organizations': OrganizationSerializer(program.authoring_organizations, many=True).data,
'credit_redemption_overview': program.credit_redemption_overview,
'courses': ProgramCourseSerializer(
program.courses,
many=True,
context={'request': request, 'program': program, 'course_runs': program.course_runs}
).data,
'corporate_endorsements': CorporateEndorsementSerializer(program.corporate_endorsements, many=True).data,
'credit_backing_organizations': OrganizationSerializer(
program.credit_backing_organizations,
many=True
).data,
'expected_learning_items': [item.value for item in program.expected_learning_items.all()],
'expected_learning_items': [],
'faq': FAQSerializer(program.faq, many=True).data,
'individual_endorsements': EndorsementSerializer(program.individual_endorsements, many=True).data,
'staff': PersonSerializer(program.staff, many=True).data,
'job_outlook_items': [item.value for item in program.job_outlook_items.all()],
'job_outlook_items': [],
'languages': [serialize_language_to_code(l) for l in program.languages],
'weeks_to_complete': program.weeks_to_complete,
'max_hours_effort_per_week': program.max_hours_effort_per_week,
'min_hours_effort_per_week': program.min_hours_effort_per_week,
'overview': program.overview,
'max_hours_effort_per_week': None,
'min_hours_effort_per_week': None,
'overview': None,
'price_ranges': [],
'subjects': SubjectSerializer(program.subjects, many=True).data,
'transcript_languages': [serialize_language_to_code(l) for l in program.transcript_languages],
})
return expected
'status': program.status,
'subjects': [],
'transcript_languages': [],
}
self.assertDictEqual(serializer.data, expected)
def test_data_with_exclusions(self):
def test_course_ordering(self):
"""
Verify we can specify program excluded_course_runs and the serializers will
render the course_runs with exclusions
Verify that courses in a program are ordered by ascending run start date,
with ties broken by earliest run enrollment start date.
"""
request = make_request()
program = self.create_program()
course_list = CourseFactory.create_batch(3)
# Create a course run with arbitrary start and empty enrollment_start.
CourseRunFactory(
course=course_list[2],
enrollment_start=None,
start=datetime(2014, 2, 1),
)
# Create a second run with matching start, but later enrollment_start.
CourseRunFactory(
course=course_list[1],
enrollment_start=datetime(2014, 1, 2),
start=datetime(2014, 2, 1),
)
excluded_course_run = program.courses.all()[0].course_runs.all()[0]
program.excluded_course_runs.add(excluded_course_run)
# Create a third run with later start and enrollment_start.
CourseRunFactory(
course=course_list[0],
enrollment_start=datetime(2014, 2, 1),
start=datetime(2014, 3, 1),
)
expected = self.get_expected_data(program, request)
program = ProgramFactory(courses=course_list)
serializer = ProgramSerializer(program, context={'request': request})
self.assertDictEqual(serializer.data, expected)
expected = ProgramCourseSerializer(
# The expected ordering is the reverse of course_list.
course_list[::-1],
many=True,
context={'request': request, 'program': program, 'course_runs': program.course_runs}
).data
self.assertEqual(serializer.data['courses'], expected)
def test_course_ordering_with_exclusions(self):
"""
Verify that excluded course runs aren't used when ordering courses.
"""
request = make_request()
course_list = CourseFactory.create_batch(3)
# Create a course run with arbitrary start and empty enrollment_start.
# This run will be excluded from the program. If it wasn't excluded,
# the expected course ordering, by index, would be: 0, 2, 1.
excluded_run = CourseRunFactory(
course=course_list[0],
enrollment_start=None,
start=datetime(2014, 1, 1),
)
# Create a run with later start and empty enrollment_start.
CourseRunFactory(
course=course_list[2],
enrollment_start=None,
start=datetime(2014, 2, 1),
)
# Create a run with matching start, but later enrollment_start.
CourseRunFactory(
course=course_list[1],
enrollment_start=datetime(2014, 1, 2),
start=datetime(2014, 2, 1),
)
# Create a run with later start and enrollment_start.
CourseRunFactory(
course=course_list[0],
enrollment_start=datetime(2014, 2, 1),
start=datetime(2014, 3, 1),
)
program = ProgramFactory(courses=course_list, excluded_course_runs=[excluded_run])
serializer = ProgramSerializer(program, context={'request': request})
expected = ProgramCourseSerializer(
# The expected ordering is the reverse of course_list.
course_list[::-1],
many=True,
context={'request': request, 'program': program, 'course_runs': program.course_runs}
).data
self.assertEqual(serializer.data['courses'], expected)
def test_course_ordering_with_no_start(self):
"""
Verify that a courses run with missing start date appears last when ordering courses.
"""
request = make_request()
course_list = CourseFactory.create_batch(3)
# Create a course run with arbitrary start and empty enrollment_start.
CourseRunFactory(
course=course_list[2],
enrollment_start=None,
start=datetime(2014, 2, 1),
)
# Create a second run with matching start, but later enrollment_start.
CourseRunFactory(
course=course_list[1],
enrollment_start=datetime(2014, 1, 2),
start=datetime(2014, 2, 1),
)
# Create a third run with empty start and enrollment_start.
CourseRunFactory(
course=course_list[0],
enrollment_start=None,
start=None,
)
program = ProgramFactory(courses=course_list)
serializer = ProgramSerializer(program, context={'request': request})
expected = ProgramCourseSerializer(
# The expected ordering is the reverse of course_list.
course_list[::-1],
many=True,
context={'request': request, 'program': program, 'course_runs': program.course_runs}
).data
self.assertEqual(serializer.data['courses'], expected)
class ContainedCourseRunsSerializerTests(TestCase):
......@@ -622,45 +772,24 @@ class VideoSerializerTests(TestCase):
self.assertDictEqual(serializer.data, expected)
class MinimalOrganizationSerializerTests(TestCase):
serializer_class = MinimalOrganizationSerializer
def create_organization(self):
return OrganizationFactory()
class OrganizationSerializerTests(TestCase):
def test_data(self):
organization = OrganizationFactory()
TAG = 'test'
organization.tags.add(TAG)
serializer = OrganizationSerializer(organization)
def get_expected_data(self, organization):
return {
'uuid': str(organization.uuid),
expected = {
'key': organization.key,
'name': organization.name,
}
def test_data(self):
organization = self.create_organization()
serializer = self.serializer_class(organization)
expected = self.get_expected_data(organization)
self.assertDictEqual(serializer.data, expected)
class OrganizationSerializerTests(MinimalOrganizationSerializerTests):
TAG = 'test-tag'
serializer_class = OrganizationSerializer
def create_organization(self):
organization = super().create_organization()
organization.tags.add(self.TAG)
return organization
def get_expected_data(self, organization):
expected = super().get_expected_data(organization)
expected.update({
'description': organization.description,
'homepage_url': organization.homepage_url,
'logo_image_url': organization.logo_image_url,
'tags': [self.TAG],
'tags': [TAG],
'marketing_url': organization.marketing_url,
})
return expected
}
self.assertDictEqual(serializer.data, expected)
class SeatSerializerTests(TestCase):
......
course_discovery/apps/api/v1/tests/test_views/test_catalogs.py
......@@ -141,7 +141,7 @@ class CatalogViewSetTests(ElasticsearchTestMixin, SerializationMixin, OAuth2Mixi
CourseRunFactory(enrollment_end=enrollment_end, course__title='ABC Test Course 2')
CourseRunFactory(enrollment_end=enrollment_end, course=self.course)
with self.assertNumQueries(40):
with self.assertNumQueries(41):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertListEqual(response.data['results'], self.serialize_catalog_course(courses, many=True))
......
course_discovery/apps/api/v1/tests/test_views/test_courses.py
......@@ -19,7 +19,7 @@ class CourseViewSetTests(SerializationMixin, APITestCase):
""" Verify the endpoint returns the details for a single course. """
url = reverse('api:v1:course-detail', kwargs={'key': self.course.key})
with self.assertNumQueries(18):
with self.assertNumQueries(19):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, self.serialize_course(self.course))
......@@ -28,7 +28,7 @@ class CourseViewSetTests(SerializationMixin, APITestCase):
""" Verify the endpoint returns a list of all courses. """
url = reverse('api:v1:course-list')
with self.assertNumQueries(24):
with self.assertNumQueries(25):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertListEqual(
......@@ -55,6 +55,6 @@ class CourseViewSetTests(SerializationMixin, APITestCase):
keys = ','.join([course.key for course in courses])
url = '{root}?keys={keys}'.format(root=reverse('api:v1:course-list'), keys=keys)
with self.assertNumQueries(35):
with self.assertNumQueries(38):
response = self.client.get(url)
self.assertListEqual(response.data['results'], self.serialize_course(courses, many=True))
course_discovery/apps/api/v1/tests/test_views/test_programs.py
......@@ -40,17 +40,15 @@ class ProgramViewSetTests(APITestCase):
def test_retrieve(self):
""" Verify the endpoint returns the details for a single program. """
program = ProgramFactory()
with self.assertNumQueries(34):
self.assert_retrieve_success(program)
self.assert_retrieve_success(program)
def test_retrieve_without_course_runs(self):
""" Verify the endpoint returns data for a program even if the program's courses have no course runs. """
course = CourseFactory()
program = ProgramFactory(courses=[course])
with self.assertNumQueries(49):
self.assert_retrieve_success(program)
self.assert_retrieve_success(program)
def assert_list_results(self, url, expected, expected_query_count):
def assert_list_results(self, url, expected):
"""
Asserts the results serialized/returned at the URL matches those that are expected.
Args:
......@@ -64,9 +62,7 @@ class ProgramViewSetTests(APITestCase):
Returns:
None
"""
with self.assertNumQueries(expected_query_count):
response = self.client.get(url)
response = self.client.get(url)
self.assertEqual(
response.data['results'],
ProgramSerializer(expected, many=True, context={'request': self.request}).data
......@@ -76,17 +72,17 @@ class ProgramViewSetTests(APITestCase):
""" Verify the endpoint returns a list of all programs. """
expected = ProgramFactory.create_batch(3)
expected.reverse()
self.assert_list_results(self.list_path, expected, 40)
self.assert_list_results(self.list_path, expected)
def test_filter_by_type(self):
""" Verify that the endpoint filters programs to those of a given type. """
program_type_name = 'foo'
program = ProgramFactory(type__name=program_type_name)
url = self.list_path + '?type=' + program_type_name
self.assert_list_results(url, [program], 18)
self.assert_list_results(url, [program])
url = self.list_path + '?type=bar'
self.assert_list_results(url, [], 4)
self.assert_list_results(url, [])
def test_filter_by_uuids(self):
""" Verify that the endpoint filters programs to those matching the provided UUIDs. """
......@@ -98,14 +94,14 @@ class ProgramViewSetTests(APITestCase):
# Create a third program, which should be filtered out.
ProgramFactory()
self.assert_list_results(url, expected, 29)
self.assert_list_results(url, expected)
@ddt.data(
(ProgramStatus.Unpublished, False, 4),
(ProgramStatus.Active, True, 40),
(ProgramStatus.Unpublished, False),
(ProgramStatus.Active, True),
)
@ddt.unpack
def test_filter_by_marketable(self, status, is_marketable, expected_query_count):
def test_filter_by_marketable(self, status, is_marketable):
""" Verify the endpoint filters programs to those that are marketable. """
url = self.list_path + '?marketable=1'
ProgramFactory(marketing_slug='')
......@@ -114,4 +110,4 @@ class ProgramViewSetTests(APITestCase):
expected = programs if is_marketable else []
self.assertEqual(list(Program.objects.marketable()), expected)
self.assert_list_results(url, expected, expected_query_count)
self.assert_list_results(url, expected)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment