def setUp(self):
super().setUp()
self.user = UserFactory()
self.client.force_authenticate(self.user)
self.catalog = CatalogFactory(query='*:*', program_query='*:*', viewers=[self.user])
self.enrollment_end = datetime.datetime.now(pytz.UTC) + datetime.timedelta(days=30)
self.course_end = datetime.datetime.now(pytz.UTC) + datetime.timedelta(days=60)
self.course_run = CourseRunFactory(enrollment_end=self.enrollment_end, end=self.course_end)
self.course = self.course_run.course
# Generate test programs
self.test_image = make_image_file('test_banner.jpg')
self.masters_program_type = ProgramType.objects.get(slug=ProgramType.MASTERS)
self.microbachelors_program_type = ProgramType.objects.get(slug=ProgramType.MICROBACHELORS)
self.ms_program = ProgramFactory(
type=self.masters_program_type,
courses=[self.course],
banner_image=self.test_image,
)
self.program = ProgramFactory(
type=self.microbachelors_program_type,
courses=[self.course],
banner_image=self.test_image,
)
self.affiliate_url = reverse('api:v1:partners:programs_affiliate_window-detail', kwargs={'pk': self.catalog.id})
def setUp(self):
super(CourseStateTests, self).setUp()
self.course = self.course_state.course
self.course.image = make_image_file('test_banner.jpg')
self.course.save()
self.course.organizations.add(factories.OrganizationExtensionFactory().organization)
def test_course_image(self):
""" Verify that the wrapper return the url fo thumbnail course image if exists. """
self.assertIsNone(self.wrapped_course_run.course_image)
self.course.image = make_image_file('test_banner1.jpg')
self.course.save()
self.assertEqual(self.wrapped_course_run.course_image,
self.course.image.thumbnail.url)
def _create_course_run_for_publication(self):
organization = OrganizationFactory()
transcript_languages = [LanguageTag.objects.first()]
mock_image_file = make_image_file('test_image.jpg')
return CourseRunFactory(course__organizations=[organization],
course__tertiary_subject=None,
course__image__from_file=mock_image_file,
lms_course_id='a/b/c',
transcript_languages=transcript_languages,
staff=PersonFactory.create_batch(2))
def test_banner_image(self):
self.program.banner_image = make_image_file('test_banner.jpg')
self.program.save()
image_url_prefix = '{}media/programs/banner_images/'.format(settings.MEDIA_URL)
self.assertIn(image_url_prefix, self.program.banner_image.url)
for size_key in self.program.banner_image.field.variations:
# Get different sizes specs from the model field
# Then get the file path from the available files
sized_file = getattr(self.program.banner_image, size_key, None)
self.assertIsNotNone(sized_file)
self.assertIn(image_url_prefix, sized_file.url)
def test_to_representation(self):
request = make_request()
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'], # pylint: disable=no-member
'height': program.banner_image.field.variations[size_key]['height'] # pylint: disable=no-member
} for size_key in program.banner_image.field.variations} # pylint: disable=no-member
assert field.to_representation(program.banner_image) == expected
def test_banner_image(self):
self.program.banner_image = make_image_file('test_banner.jpg')
self.program.save()
image_url_prefix = '{}media/programs/banner_images/'.format(
settings.MEDIA_URL)
self.assertIn(image_url_prefix, self.program.banner_image.url)
for size_key in self.program.banner_image.field.variations:
# Get different sizes specs from the model field
# Then get the file path from the available files
sized_file = getattr(self.program.banner_image, size_key, None)
self.assertIsNotNone(sized_file)
self.assertIn(image_url_prefix, sized_file.url)
def test_update(self):
"""
Verify that we can update course workflow state with serializer.
"""
course = self.course_state.course
course.image = make_image_file('test_banner.jpg')
course.save()
course.organizations.add(OrganizationExtensionFactory().organization)
self.assertNotEqual(self.course_state, CourseStateChoices.Review)
serializer = self.serializer_class(self.course_state, context={'request': self.request})
data = {'name': CourseStateChoices.Review}
serializer.update(self.course_state, data)
self.course_state = CourseState.objects.get(course=self.course_state.course)
self.assertEqual(self.course_state.name, CourseStateChoices.Review)
self.assertEqual(self.course_state.owner_role, PublisherUserRole.MarketingReviewer)
def setUp(self):
super(ChangeCourseStateViewTests, self).setUp()
self.course_state = factories.CourseStateFactory(name=CourseStateChoices.Draft)
self.user = UserFactory()
self.user.groups.add(Group.objects.get(name=INTERNAL_USER_GROUP_NAME))
self.course = self.course_state.course
self.course.image = make_image_file('test_banner.jpg')
self.course.save()
self.organization_extension = factories.OrganizationExtensionFactory()
self.course.organizations.add(self.organization_extension.organization)
factories.UserAttributeFactory(user=self.user, enable_email_notification=True)
toggle_switch('enable_publisher_email_notifications', True)
self.change_state_url = reverse('publisher:api:change_course_state', kwargs={'pk': self.course_state.id})
self.client.login(username=self.user.username, password=USER_PASSWORD)
def create_program(self):
organizations = [OrganizationFactory()]
person = PersonFactory()
course = CourseFactory()
CourseRunFactory(course=course, staff=[person])
program = ProgramFactory(
courses=[course],
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()
)
return program
def test_program_activation_restrictions(self, booleans, label):
"""Verify that program activation requires both a marketing slug and a banner image."""
has_banner_image, can_be_activated = booleans
status = getattr(ProgramStatus, label)
banner_image = make_image_file('test_banner.jpg') if has_banner_image else ''
data = self._post_data(status=status, marketing_slug='/foo')
files = {'banner_image': banner_image}
if status == ProgramStatus.Active:
if can_be_activated:
# Transitioning to an active status should require a marketing slug and banner image.
self.assert_form_valid(data, files)
else:
self.assert_form_invalid(data, files)
else:
# All other status transitions should be valid regardless of marketing slug and banner image.
self.assert_form_valid(data, files)
def create_program(self):
organizations = [OrganizationFactory()]
person = PersonFactory()
course = CourseFactory()
CourseRunFactory(course=course, staff=[person])
program = ProgramFactory(
courses=[course],
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())
return program
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], start=datetime.now())
return 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(),
order_courses_by_start_date=False,
)
def test_program_activation_restrictions(self, booleans, label):
"""Verify that program activation requires both a marketing slug and a banner image."""
has_marketing_slug, has_banner_image, can_be_activated = booleans
status = getattr(ProgramStatus, label)
marketing_slug = '/foo' if has_marketing_slug else ''
banner_image = make_image_file('test_banner.jpg') if has_banner_image else ''
data = self._post_data(status=status, marketing_slug=marketing_slug)
files = {'banner_image': banner_image}
if status == ProgramStatus.Active:
if can_be_activated:
# Transitioning to an active status should require a marketing slug and banner image.
self.assert_form_valid(data, files)
else:
self.assert_form_invalid(data, files)
else:
# All other status transitions should be valid regardless of marketing slug and banner image.
self.assert_form_valid(data, files)
def test_course_image_url(self):
""" Verify that the property returns the course image url. """
self.assertIsNone(self.course.course_image_url)
# Create a published course-run with card_image_url.
course_run = factories.CourseRunFactory(course=self.course)
factories.CourseRunStateFactory(course_run=course_run,
name=CourseRunStateChoices.Published)
course_run.card_image_url = 'http://example.com/test.jpg'
course_run.save()
# Verify that property returns card_image_url of course-run.
self.assertEqual(self.course.course_image_url,
course_run.card_image_url)
# Create a course image.
self.course.image = make_image_file('test_banner1.jpg')
self.course.save()
# Verify that property returns course image field url.
self.assertEqual(self.course.course_image_url, self.course.image.url)
def create_program(self, courses=None):
organizations = [OrganizationFactory(partner=self.partner)]
person = PersonFactory()
if courses is None:
courses = [CourseFactory(partner=self.partner)]
CourseRunFactory(course=courses[0], staff=[person])
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),
instructor_ordering=PersonFactory.create_batch(1),
banner_image=make_image_file('test_banner.jpg'),
video=VideoFactory(),
partner=self.partner)
return program
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)
def setUp(self):
super(CreateCoursesTests, self).setUp()
transcript_languages = LanguageTag.objects.all()[:2]
self.subjects = SubjectFactory.create_batch(3)
self.test_image = make_image_file('testimage.jpg')
self.course = CourseFactory(subjects=self.subjects,
image__from_file=self.test_image)
self.command_name = 'import_metadata_courses'
self.command_args = [
'--start_id={}'.format(self.course.id),
'--end_id={}'.format(self.course.id)
]
# create multiple course-runs against course.
course_runs = CourseRunFactory.create_batch(
3,
course=self.course,
transcript_languages=transcript_languages,
language=transcript_languages[0],
short_description_override='Testing description')
canonical_course_run = course_runs[0]
for seat_type in ['honor', 'credit',
'verified']: # to avoid same type seat creation.
SeatFactory(course_run=canonical_course_run, type=seat_type)
staff = PersonFactory.create_batch(2)
canonical_course_run.staff.add(*staff)
self.course.canonical_course_run = canonical_course_run
self.course.save()
# create org and assign to the course-metadata
self.forganization_extension = factories.OrganizationExtensionFactory()
self.organization = self.forganization_extension.organization
self.course.authoring_organizations.add(self.organization)
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],
start=datetime.now())
return 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(),
order_courses_by_start_date=False,
)
