Skip to content

C
course-discovery
Commit 4ffb74de by Clinton Blackburn
Options

Fixed broken tests

parent 83a32240
Showing with 77 additions and 147 deletions
course_discovery/apps/api/serializers.py
......@@ -333,6 +333,7 @@ class ContainedCourseRunsSerializer(serializers.Serializer):
class MinimalCourseSerializer(TimestampModelSerializer):
course_runs = MinimalCourseRunSerializer(many=True)
owners = MinimalOrganizationSerializer(many=True, source='authoring_organizations')
class Meta:
......
course_discovery/apps/api/tests/test_serializers.py
import unittest
from datetime import datetime
from urllib.parse import urlencode
......@@ -10,7 +9,7 @@ from rest_framework.test import APIRequestFactory
from course_discovery.apps.api.fields import ImageField
from course_discovery.apps.api.serializers import (
CatalogSerializer, CourseSerializer, CourseRunSerializer, ContainedCoursesSerializer, ImageSerializer,
CatalogSerializer, CourseRunSerializer, ContainedCoursesSerializer, ImageSerializer,
SubjectSerializer, PrerequisiteSerializer, VideoSerializer, OrganizationSerializer, SeatSerializer,
PersonSerializer, AffiliateWindowSerializer, ContainedCourseRunsSerializer, CourseRunSearchSerializer,
ProgramSerializer, ProgramSearchSerializer, ProgramCourseSerializer, NestedProgramSerializer,
......@@ -195,7 +194,6 @@ 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 = {
......@@ -245,7 +243,7 @@ class FlattenedCourseRunWithCourseSerializerTests(TestCase): # pragma: no cover
def get_expected_data(self, request, course_run):
course = course_run.course
serializer_context = {'request': request}
expected = CourseRunSerializer(course_run, context=serializer_context).data
expected = dict(CourseRunSerializer(course_run, context=serializer_context).data)
expected.update({
'subjects': self.serialize_items(course.subjects.all(), 'name'),
'seats': self.serialize_seats(course_run),
......@@ -288,8 +286,6 @@ class FlattenedCourseRunWithCourseSerializerTests(TestCase): # pragma: no cover
@ddt.ddt
class ProgramCourseSerializerTests(TestCase):
maxDiff = None
def setUp(self):
super(ProgramCourseSerializerTests, self).setUp()
self.request = make_request()
......@@ -310,7 +306,6 @@ class ProgramCourseSerializerTests(TestCase):
self.assertSequenceEqual(serializer.data, expected)
@unittest.skip('@clintonb to fix later')
def test_with_runs(self):
for course in self.course_list:
CourseRunFactory.create_batch(2, course=course)
......@@ -342,86 +337,37 @@ class ProgramCourseSerializerTests(TestCase):
context={'request': self.request}).data
self.assertDictEqual(serializer.data, expected)
@unittest.skip('@clintonb to fix later')
@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
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)
for course in self.course_list:
CourseRunFactory.create_batch(2, status=course_run_status, course=course)
serializer = ProgramCourseSerializer(
self.course_list,
courses,
many=True,
context={
'request': self.request,
'program': self.program,
'published_course_runs_only': published_course_runs_only,
'program': program,
'published_course_runs_only': True,
}
)
validate_data = serializer.data
if not published_course_runs_only or course_run_status != CourseRunStatus.Unpublished:
expected = MinimalCourseSerializer(self.course_list, many=True, context={'request': self.request}).data
self.assertSequenceEqual(validate_data, expected)
self.assertSequenceEqual(serializer.data, expected)
class ProgramSerializerTests(TestCase):
maxDiff = None
@unittest.skip('@clintonb to fix later')
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(
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,
)
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
}
expected = {
def get_expected_data(self, program, request):
return {
'uuid': str(program.uuid),
'title': program.title,
'subtitle': program.subtitle,
......@@ -429,8 +375,18 @@ class ProgramSerializerTests(TestCase):
'marketing_slug': program.marketing_slug,
'marketing_url': program.marketing_url,
'card_image_url': program.card_image_url,
'video': None,
'banner_image': expected_banner_image_urls,
'video': VideoSerializer(program.video),
'banner_image': {
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
},
'authoring_organizations': MinimalOrganizationSerializer(program.authoring_organizations, many=True).data,
'credit_redemption_overview': program.credit_redemption_overview,
'courses': ProgramCourseSerializer(
......@@ -450,80 +406,56 @@ class ProgramSerializerTests(TestCase):
'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,
'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,
'price_ranges': [],
'status': program.status,
'subjects': [],
'transcript_languages': [],
'subjects': SubjectSerializer(program.subjects, many=True),
'transcript_languages': [language.code for language in program.transcript_languages],
}
def create_program(self):
organization = OrganizationFactory()
courses = CourseFactory.create_batch(3)
for course in courses:
CourseRunFactory.create_batch(2, course=course, staff=[PersonFactory()])
corporate_endorsements = CorporateEndorsementFactory.create_batch(1)
individual_endorsements = EndorsementFactory.create_batch(1)
job_outlook_items = JobOutlookItemFactory.create_batch(1)
expected_learning_items = ExpectedLearningItemFactory.create_batch(1)
program = ProgramFactory(
authoring_organizations=[organization],
courses=courses,
credit_backing_organizations=[organization],
corporate_endorsements=corporate_endorsements,
individual_endorsements=individual_endorsements,
expected_learning_items=expected_learning_items,
job_outlook_items=job_outlook_items,
banner_image=make_image_file('test_banner.jpg')
)
return program
def test_data(self):
request = make_request()
program = self.create_program()
expected = self.get_expected_data(program, request)
serializer = ProgramSerializer(program, context={'request': request})
self.assertDictEqual(serializer.data, expected)
def test_with_exclusions(self):
def test_data_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])
program = ProgramFactory(
authoring_organizations=org_list,
courses=course_list,
excluded_course_runs=excluded_runs
)
serializer = ProgramSerializer(program, context={'request': request})
program = self.create_program()
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,
'card_image_url': program.card_image_url,
'banner_image': {},
'video': None,
'authoring_organizations': MinimalOrganizationSerializer(program.authoring_organizations, many=True).data,
'credit_redemption_overview': program.credit_redemption_overview,
'courses': ProgramCourseSerializer(
program.courses,
many=True,
context={'request': request, 'program': program}
).data,
'corporate_endorsements': CorporateEndorsementSerializer(program.corporate_endorsements, many=True).data,
'credit_backing_organizations': MinimalOrganizationSerializer(
program.credit_backing_organizations,
many=True
).data,
'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': [],
'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': [],
}
excluded_course_run = program.courses.all()[0].course_runs.all()[0]
program.excluded_course_runs.add(excluded_course_run)
expected = self.get_expected_data(program, request)
serializer = ProgramSerializer(program, context={'request': request})
self.assertDictEqual(serializer.data, expected)
......@@ -650,8 +582,6 @@ class VideoSerializerTests(TestCase):
class OrganizationSerializerTests(TestCase):
maxDiff = None
def test_data(self):
organization = OrganizationFactory()
TAG = 'test'
......
course_discovery/apps/course_metadata/tests/factories.py
......@@ -239,13 +239,17 @@ class ProgramFactory(factory.django.DjangoModelFactory):
title = factory.Sequence(lambda n: 'test-program-{}'.format(n)) # pylint: disable=unnecessary-lambda
uuid = factory.LazyFunction(uuid4)
subtitle = 'test-subtitle'
subtitle = FuzzyText()
type = factory.SubFactory(ProgramTypeFactory)
status = ProgramStatus.Unpublished
marketing_slug = factory.Sequence(lambda n: 'test-slug-{}'.format(n)) # pylint: disable=unnecessary-lambda
banner_image_url = FuzzyText(prefix='https://example.com/program/banner')
card_image_url = FuzzyText(prefix='https://example.com/program/card')
partner = factory.SubFactory(PartnerFactory)
overview = FuzzyText()
weeks_to_complete = FuzzyInteger(1)
min_hours_effort_per_week = FuzzyInteger(2)
max_hours_effort_per_week = FuzzyInteger(4)
credit_redemption_overview = FuzzyText()
@factory.post_generation
......@@ -289,11 +293,6 @@ class ProgramFactory(factory.django.DjangoModelFactory):
add_m2m_data(self.individual_endorsements, extracted)
@factory.post_generation
def staff(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.staff, extracted)
@factory.post_generation
def job_outlook_items(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.job_outlook_items, extracted)
......
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