def get_verification_context(self, request, course):
course_key = CourseKey.from_string(unicode(course.id))
# Establish whether the course has a verified mode
available_modes = CourseMode.modes_for_course_dict(unicode(course.id))
has_verified_mode = CourseMode.has_verified_mode(available_modes)
# Establish whether the user is already enrolled
is_already_verified = CourseEnrollment.is_enrolled_as_verified(request.user, course_key)
# Establish whether the verification deadline has already passed
verification_deadline = VerifiedUpgradeDeadlineDate(course, request.user)
deadline_has_passed = verification_deadline.deadline_has_passed()
# If this proves its worth, we can internationalize and display for more than English speakers.
show_course_sock = (
has_verified_mode and not is_already_verified and
not deadline_has_passed and get_language() == 'en'
)
# Get information about the upgrade
course_price = get_cosmetic_verified_display_price(course)
upgrade_url = EcommerceService().upgrade_url(request.user, course_key)
context = {
'show_course_sock': show_course_sock,
'course_price': course_price,
'course_id': course.id,
'upgrade_url': upgrade_url,
}
return context
def get_verification_context(self, request, course):
course_key = CourseKey.from_string(unicode(course.id))
# Establish whether the course has a verified mode
available_modes = CourseMode.modes_for_course_dict(unicode(course.id))
has_verified_mode = CourseMode.has_verified_mode(available_modes)
# Establish whether the user is already enrolled
is_already_verified = CourseEnrollment.is_enrolled_as_verified(
request.user, course_key)
# Establish whether the verification deadline has already passed
verification_deadline = VerifiedUpgradeDeadlineDate(
course, request.user)
deadline_has_passed = verification_deadline.deadline_has_passed()
# If this proves its worth, we can internationalize and display for more than English speakers.
show_course_sock = (has_verified_mode and not is_already_verified
and not deadline_has_passed
and get_language() == 'en')
# Get information about the upgrade
course_price = get_cosmetic_verified_display_price(course)
upgrade_url = EcommerceService().upgrade_url(request.user, course_key)
context = {
'show_course_sock': show_course_sock,
'course_price': course_price,
'course_id': course.id,
'upgrade_url': upgrade_url,
}
return context
def test_date_with_existing_schedule(self):
""" If a schedule is created while deadlines are disabled, they shouldn't magically appear once the feature is
turned on. """
course = create_self_paced_course_run(days_till_start=-1)
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=False)
course_config = CourseDynamicUpgradeDeadlineConfiguration.objects.create(
enabled=False, course_id=course.id)
enrollment = CourseEnrollmentFactory(course_id=course.id,
mode=CourseMode.AUDIT)
# The enrollment has a schedule, but the upgrade deadline should be None
self.assertIsNone(enrollment.schedule.upgrade_deadline)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = CourseMode.objects.get(
course_id=course.id,
mode_slug=CourseMode.VERIFIED).expiration_datetime
self.assertEqual(block.date, expected)
# Now if we turn on the feature for this course, this existing enrollment should be unaffected
course_config.enabled = True
course_config.save()
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
self.assertEqual(block.date, expected)
def get_verification_context(self, request, course):
course_key = CourseKey.from_string(unicode(course.id))
# Establish whether the course has a verified mode
available_modes = CourseMode.modes_for_course_dict(unicode(course.id))
has_verified_mode = CourseMode.has_verified_mode(available_modes)
# Establish whether the user is already enrolled
is_already_verified = CourseEnrollment.is_enrolled_as_verified(request.user.id, course_key)
# Establish whether the verification deadline has already passed
verification_deadline = VerifiedUpgradeDeadlineDate(course, request.user)
deadline_has_passed = verification_deadline.deadline_has_passed()
show_course_sock = has_verified_mode and not is_already_verified and not deadline_has_passed
# Get the price of the course and format correctly
course_price = get_cosmetic_verified_display_price(course)
context = {
'show_course_sock': show_course_sock,
'course_price': course_price,
'course_id': course.id
}
return context
def test_date_with_self_paced_with_enrollment_after_course_start(self):
""" Enrolling after a course begins should result in the upgrade deadline being set relative to the
enrollment date.
Additionally, OrgDynamicUpgradeDeadlineConfiguration should override the number of days until the deadline,
and CourseDynamicUpgradeDeadlineConfiguration should override the org-level override.
"""
global_config = DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
course = create_self_paced_course_run(days_till_start=-1, org_id='TestOrg')
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = enrollment.created + timedelta(days=global_config.deadline_days)
self.assertEqual(block.date, expected)
# Orgs should be able to override the deadline
org_config = OrgDynamicUpgradeDeadlineConfiguration.objects.create(
enabled=True, org_id=course.org, deadline_days=4
)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = enrollment.created + timedelta(days=org_config.deadline_days)
self.assertEqual(block.date, expected)
# Courses should be able to override the deadline (and the org-level override)
course_config = CourseDynamicUpgradeDeadlineConfiguration.objects.create(
enabled=True, course_id=course.id, deadline_days=3
)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = enrollment.created + timedelta(days=course_config.deadline_days)
self.assertEqual(block.date, expected)
def get_verification_context(self, request, course):
course_key = CourseKey.from_string(unicode(course.id))
# Establish whether the course has a verified mode
available_modes = CourseMode.modes_for_course_dict(unicode(course.id))
has_verified_mode = CourseMode.has_verified_mode(available_modes)
# Establish whether the user is already enrolled
is_already_verified = CourseEnrollment.is_enrolled_as_verified(
request.user, course_key)
# Establish whether the verification deadline has already passed
verification_deadline = VerifiedUpgradeDeadlineDate(
course, request.user)
deadline_has_passed = verification_deadline.deadline_has_passed()
show_course_sock = has_verified_mode and not is_already_verified and not deadline_has_passed
# Get the price of the course and format correctly
course_price = get_cosmetic_verified_display_price(course)
context = {
'show_course_sock': show_course_sock,
'course_price': course_price,
'course_id': course.id
}
return context
def test_verified_upgrade_deadline_alert(self, current_time, expected_message_html):
"""
Verify the verified upgrade deadline alerts.
"""
with freeze_time(current_time):
block = VerifiedUpgradeDeadlineDate(self.course, self.request.user)
block.register_alerts(self.request, self.course)
messages = list(CourseHomeMessages.user_messages(self.request))
if expected_message_html:
self.assertEqual(len(messages), 1)
self.assertIn(expected_message_html, messages[0].message_html)
else:
self.assertEqual(len(messages), 0)
def test_verified_upgrade_deadline_alert(self, current_time, expected_message_html):
"""
Verify the verified upgrade deadline alerts.
"""
with freeze_time(current_time):
block = VerifiedUpgradeDeadlineDate(self.course, self.request.user)
block.register_alerts(self.request, self.course)
messages = list(CourseHomeMessages.user_messages(self.request))
if expected_message_html:
self.assertEqual(len(messages), 1)
self.assertIn(expected_message_html, messages[0].message_html)
else:
self.assertEqual(len(messages), 0)
def test_without_upgrade_deadline(self):
self.setup_course_and_user(enrollment_mode=None)
self.client.login(username='******', password='******')
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertFalse(block.is_enabled)
self.assertIsNone(block.date)
self.check_upgrade_banner(banner_expected=False)
def test_verified_upgrade_banner_not_present_past_deadline(self):
self.setup_course_and_user(days_till_upgrade_deadline=-1,
user_enrollment_mode=CourseMode.AUDIT)
self.client.login(username='******', password='******')
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertFalse(block.is_enabled)
self.check_upgrade_banner(banner_expected=False)
def test_verified_upgrade_deadline_date(self):
self.setup_course_and_user(days_till_upgrade_deadline=1, user_enrollment_mode=CourseMode.AUDIT)
self.client.login(username='******', password='******')
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertEqual(block.date, datetime.now(utc) + timedelta(days=1))
self.assertTrue(block.is_enabled)
self.assertEqual(block.link, reverse('verify_student_upgrade_and_verify', args=(self.course.id,)))
self.check_upgrade_banner()
def test_verified_upgrade_deadline_date(self):
self.setup_course_and_user(days_till_upgrade_deadline=1)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertEqual(block.date, datetime.now(utc) + timedelta(days=1))
self.assertEqual(
block.link,
reverse('verify_student_upgrade_and_verify',
args=(self.course.id, )))
def test_date_with_self_paced_with_enrollment_after_course_start(self):
""" Enrolling after a course begins should result in the upgrade deadline being set relative to the
enrollment date. """
global_config = DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
course = self.create_self_paced_course_run(days_till_start=-1)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = enrollment.created + timedelta(days=global_config.deadline_days)
self.assertEqual(block.date, expected)
# Courses should be able to override the deadline
course_config = CourseDynamicUpgradeDeadlineConfiguration.objects.create(
enabled=True, course_id=course.id, opt_out=False, deadline_days=3
)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = enrollment.created + timedelta(days=course_config.deadline_days)
self.assertEqual(block.date, expected)
def test_date_with_self_paced_without_dynamic_upgrade_deadline(self):
""" Disabling the dynamic upgrade deadline functionality should result in the verified mode's
expiration date being returned. """
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=False)
course = create_self_paced_course_run()
expected = CourseMode.objects.get(course_id=course.id, mode_slug=CourseMode.VERIFIED).expiration_datetime
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
self.assertEqual(block.date, expected)
def test_date_with_self_paced(self):
""" The date returned for self-paced course runs should be dependent on the learner's enrollment date. """
global_config = DynamicUpgradeDeadlineConfiguration.objects.create(
enabled=True)
# Enrollments made before the course start should use the course start date as the content availability date
self.create_self_paced_course_run(days_till_start=3)
CourseEnrollmentFactory.create(course_id=self.course.id,
user=self.user,
mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
overview = CourseOverview.get_from_id(self.course.id)
expected = overview.start + timedelta(days=global_config.deadline_days)
self.assertEqual(block.date, expected)
# Enrollments made after the course start should use the enrollment date as the content availability date
self.create_self_paced_course_run(days_till_start=-1)
enrollment = CourseEnrollmentFactory.create(course_id=self.course.id,
user=self.user,
mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
expected = enrollment.created + timedelta(
days=global_config.deadline_days)
self.assertEqual(block.date, expected)
# Courses should be able to override the deadline
course_config = CourseDynamicUpgradeDeadlineConfiguration.objects.create(
enabled=True,
course_id=self.course.id,
opt_out=False,
deadline_days=3)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
expected = enrollment.created + timedelta(
days=course_config.deadline_days)
self.assertEqual(block.date, expected)
# Disabling the functionality should result in the verified mode's expiration date being returned.
global_config.enabled = False
global_config.save()
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
expected = CourseMode.objects.get(
course_id=self.course.id,
mode_slug=CourseMode.VERIFIED).expiration_datetime
self.assertEqual(block.date, expected)
def test_date_with_self_paced_with_course_opt_out(self):
""" If the course run has opted out of the dynamic deadline, the course mode's deadline should be used. """
course = self.create_self_paced_course_run(days_till_start=-1)
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
CourseDynamicUpgradeDeadlineConfiguration.objects.create(enabled=True, course_id=course.id, opt_out=True)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = CourseMode.objects.get(course_id=course.id, mode_slug=CourseMode.VERIFIED).expiration_datetime
self.assertEqual(block.date, expected)
def test_date_with_self_paced_with_single_course(self):
""" If the global switch is off, a single course can still be enabled. """
course = create_self_paced_course_run(days_till_start=-1)
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=False)
course_config = CourseDynamicUpgradeDeadlineConfiguration.objects.create(enabled=True, course_id=course.id)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
expected = enrollment.created + timedelta(days=course_config.deadline_days)
self.assertEqual(block.date, expected)
def test_date_with_self_paced_with_enrollment_before_course_start(self):
""" Enrolling before a course begins should result in the upgrade deadline being set relative to the
course start date. """
global_config = DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
course = create_self_paced_course_run(days_till_start=3)
overview = CourseOverview.get_from_id(course.id)
expected = overview.start + timedelta(days=global_config.deadline_days)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
self.assertEqual(block.date, expected)
def test_ecommerce_checkout_redirect(self):
"""Verify the block link redirects to ecommerce checkout if it's enabled."""
sku = 'TESTSKU'
checkout_page = '/test_basket/'
CommerceConfiguration.objects.create(
checkout_on_ecommerce_service=True,
single_course_checkout_page=checkout_page)
self.setup_course_and_user(sku=sku)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertEqual(block.link, '{}?sku={}'.format(checkout_page, sku))
def test_ecommerce_checkout_redirect(self):
"""Verify the block link redirects to ecommerce checkout if it's enabled."""
sku = 'TESTSKU'
configuration = CommerceConfiguration.objects.create(
checkout_on_ecommerce_service=True)
self.setup_course_and_user(sku=sku)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertEqual(
block.link,
'{}?sku={}'.format(configuration.MULTIPLE_ITEMS_BASKET_PAGE_URL,
sku))
def check_and_get_upgrade_link(user, course_id):
"""
For an authenticated user, return a link to allow them to upgrade
in the specified course.
"""
if user.is_authenticated():
upgrade_data = VerifiedUpgradeDeadlineDate(None,
user,
course_id=course_id)
if upgrade_data.is_enabled:
return upgrade_data
return None
def test_ecommerce_checkout_redirect(self):
"""Verify the block link redirects to ecommerce checkout if it's enabled."""
sku = 'TESTSKU'
configuration = CommerceConfiguration.objects.create(checkout_on_ecommerce_service=True)
course = create_course_run()
user = create_user()
course_mode = CourseMode.objects.get(course_id=course.id, mode_slug=CourseMode.VERIFIED)
course_mode.sku = sku
course_mode.save()
CourseEnrollmentFactory(course_id=course.id, user=user, mode=CourseMode.VERIFIED)
block = VerifiedUpgradeDeadlineDate(course, user)
self.assertEqual(block.link, '{}?sku={}'.format(configuration.basket_checkout_page, sku))
def assert_upgrade_deadline(self, course, expected):
""" Asserts the VerifiedUpgradeDeadlineDate block's date matches the expected value. """
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
block = VerifiedUpgradeDeadlineDate(course, enrollment.user)
self.assertEqual(block.date, expected)
def test_without_upgrade_deadline(self):
self.setup_course_and_user(enrollment_mode=None)
block = VerifiedUpgradeDeadlineDate(self.course, self.user)
self.assertIsNone(block.date)
