def test_fulfilled_entitlement(self, mock_course_overview,
mock_course_runs, mock_get_programs):
"""
When a learner has a fulfilled entitlement, their course dashboard should have:
- exactly one course item, meaning it:
- has an entitlement card
- does NOT have a course card referencing the selected session
- an unhidden Change or Leave Session button
- a related programs message
"""
mocked_course_overview = CourseOverviewFactory(
start=self.TOMORROW, self_paced=True, enrollment_end=self.TOMORROW)
mock_course_overview.return_value = mocked_course_overview
course_enrollment = CourseEnrollmentFactory(
user=self.user, course_id=six.text_type(mocked_course_overview.id))
mock_course_runs.return_value = [{
'key':
str(mocked_course_overview.id),
'enrollment_end':
str(mocked_course_overview.enrollment_end),
'pacing_type':
'self_paced',
'type':
'verified',
'status':
'published'
}]
entitlement = CourseEntitlementFactory(
user=self.user, enrollment_course_run=course_enrollment)
program = ProgramFactory()
program['courses'][0]['course_runs'] = [{
'key':
six.text_type(mocked_course_overview.id)
}]
program['courses'][0]['uuid'] = entitlement.course_uuid
mock_get_programs.return_value = [program]
response = self.client.get(self.path)
self.assertContains(response, '<li class="course-item">', count=1)
self.assertContains(response,
'<button class="change-session btn-link "')
self.assertContains(response, 'Related Programs:')
def test_unfulfilled_expired_entitlement(self, mock_course_overview,
mock_course_runs):
"""
When a learner has an unfulfilled, expired entitlement, a card should NOT appear on the dashboard.
This use case represents either an entitlement that the user waited too long to fulfill, or an entitlement
for which they received a refund.
"""
CourseEntitlementFactory(user=self.user,
created=self.THREE_YEARS_AGO,
expired_at=now())
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
mock_course_runs.return_value = [{
'key': 'course-v1:FAKE+FA1-MA1.X+3T2017',
'enrollment_end': str(self.TOMORROW),
'pacing_type': 'instructor_paced',
'type': 'verified',
'status': 'published'
}]
response = self.client.get(self.path)
self.assertNotContains(response, '<li class="course-item">')
def test_unpublished_sessions_for_entitlement(self, mock_get_edx_api_data):
"""
Test unpublished course runs are not part of visible session entitlements when the user
is not enrolled and upgrade deadline is passed.
"""
catalog_course_run = CourseRunFactory.create(status=COURSE_UNPUBLISHED)
catalog_course = CourseFactory(course_runs=[catalog_course_run])
mock_get_edx_api_data.return_value = catalog_course
course_key = CourseKey.from_string(catalog_course_run.get('key'))
course_overview = CourseOverviewFactory.create(id=course_key,
start=self.tomorrow)
CourseModeFactory.create(mode_slug=CourseMode.VERIFIED,
min_price=100,
course_id=course_overview.id,
expiration_datetime=now() - timedelta(days=1))
entitlement = CourseEntitlementFactory(user=self.user,
mode=CourseMode.VERIFIED)
session_entitlements = get_visible_sessions_for_entitlement(
entitlement)
self.assertEqual(session_entitlements, [])
def test_email_settings_fulfilled_entitlement(self, mock_email_feature,
mock_get_course_runs):
"""
Assert that the Email Settings action is shown when the user has a fulfilled entitlement.
"""
mock_email_feature.return_value = True
course_overview = CourseOverviewFactory(start=self.TOMORROW,
self_paced=True,
enrollment_end=self.TOMORROW)
course_enrollment = CourseEnrollmentFactory(user=self.user)
entitlement = CourseEntitlementFactory(
user=self.user, enrollment_course_run=course_enrollment)
course_runs = [{
'key': unicode(course_overview.id),
'uuid': entitlement.course_uuid
}]
mock_get_course_runs.return_value = course_runs
response = self.client.get(self.path)
self.assertEqual(
pq(response.content)(self.EMAIL_SETTINGS_ELEMENT_ID).length, 1)
def test_revoke_unenroll_entitlement(self):
course_entitlement = CourseEntitlementFactory()
url = reverse(self.ENTITLEMENTS_DETAILS_PATH, args=[str(course_entitlement.uuid)])
enrollment = CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
course_entitlement.refresh_from_db()
course_entitlement.enrollment_course_run = enrollment
course_entitlement.save()
assert course_entitlement.enrollment_course_run is not None
response = self.client.delete(
url,
content_type='application/json',
)
assert response.status_code == 204
course_entitlement.refresh_from_db()
assert course_entitlement.expired_at is not None
assert course_entitlement.enrollment_course_run is None
def test_data(self):
entitlement = CourseEntitlementFactory()
request = RequestFactory().get('')
serializer = CourseEntitlementSerializer(entitlement,
context={'request': request})
expected = {
'user': entitlement.user.username,
'uuid': str(entitlement.uuid),
'expired_at': entitlement.expired_at,
'course_uuid': str(entitlement.course_uuid),
'mode': entitlement.mode,
'refund_locked': False,
'enrollment_course_run': None,
'order_number': entitlement.order_number,
'created': entitlement.created.strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
'modified': entitlement.modified.strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
'support_details': [],
}
assert serializer.data == expected
def test_unfulfilled_expired_entitlement(self, mock_course_overview,
mock_course_runs):
"""
When a learner has an unfulfilled, expired entitlement, their course dashboard should have:
- a hidden 'View Course' button
- a message saying that they can no longer select a session
"""
CourseEntitlementFactory(user=self.user, created=self.THREE_YEARS_AGO)
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
mock_course_runs.return_value = [{
'key': 'course-v1:FAKE+FA1-MA1.X+3T2017',
'enrollment_end': self.TOMORROW,
'pacing_type': 'instructor_paced',
'type': 'verified'
}]
response = self.client.get(self.path)
self.assertIn('class="enter-course hidden"', response.content)
self.assertIn('You can no longer select a session', response.content)
self.assertNotIn(
'<div class="course-entitlement-selection-container ">',
response.content)
def test_unfulfilled_entitlement(self, mock_course_overview,
mock_course_runs):
"""
When a learner has an unfulfilled entitlement, their course dashboard should have:
- a hidden 'View Course' button
- the text 'In order to view the course you must select a session:'
- an unhidden course-entitlement-selection-container
"""
CourseEntitlementFactory(user=self.user)
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
mock_course_runs.return_value = [{
'key': 'course-v1:FAKE+FA1-MA1.X+3T2017',
'enrollment_end': self.TOMORROW,
'pacing_type': 'instructor_paced',
'type': 'verified'
}]
response = self.client.get(self.path)
self.assertIn('class="enter-course hidden"', response.content)
self.assertIn('You must select a session to access the course.',
response.content)
self.assertIn('<div class="course-entitlement-selection-container ">',
response.content)
def test_get_visible_sessions_for_entitlement(self, mock_get_edx_api_data):
"""
Test retrieval of visible session entitlements.
"""
catalog_course_run = CourseRunFactory.create()
catalog_course = CourseFactory(course_runs=[catalog_course_run])
mock_get_edx_api_data.return_value = catalog_course
course_key = CourseKey.from_string(catalog_course_run.get('key'))
course_overview = CourseOverviewFactory.create(id=course_key,
start=self.tomorrow)
CourseModeFactory.create(mode_slug=CourseMode.VERIFIED,
min_price=100,
course_id=course_overview.id)
course_enrollment = CourseEnrollmentFactory(user=self.user,
course=course_overview,
mode=CourseMode.VERIFIED)
entitlement = CourseEntitlementFactory(
user=self.user,
enrollment_course_run=course_enrollment,
mode=CourseMode.VERIFIED)
session_entitlements = get_visible_sessions_for_entitlement(
entitlement)
self.assertEqual(session_entitlements, [catalog_course_run])
def test_sessions_for_entitlement_course_runs(self, mock_course_overview, mock_course_runs):
"""
When a learner has a fulfilled entitlement for a course run in the past, there should be no availableSession
data passed to the JS view. When a learner has a fulfilled entitlement for a course run enrollment ending in the
future, there should not be an empty availableSession variable. When a learner has a fulfilled entitlement
for a course that doesn't have an enrollment ending, there should not be an empty availableSession variable.
NOTE: We commented out the assertions to move this to the catalog utils test suite.
"""
# noAvailableSessions = "availableSessions: '[]'"
# Test an enrollment end in the past
mocked_course_overview = CourseOverviewFactory.create(
start=self.TOMORROW, end=self.THREE_YEARS_FROM_NOW, self_paced=True, enrollment_end=self.THREE_YEARS_AGO
)
mock_course_overview.return_value = mocked_course_overview
course_enrollment = CourseEnrollmentFactory(user=self.user, course_id=six.text_type(mocked_course_overview.id))
mock_course_runs.return_value = [
{
'key': str(mocked_course_overview.id),
'enrollment_end': str(mocked_course_overview.enrollment_end),
'pacing_type': 'self_paced',
'type': 'verified',
'status': 'published'
}
]
CourseEntitlementFactory(user=self.user, enrollment_course_run=course_enrollment)
# response = self.client.get(self.path)
# self.assertIn(noAvailableSessions, response.content)
# Test an enrollment end in the future sets an availableSession
mocked_course_overview.enrollment_end = self.TOMORROW
mocked_course_overview.save()
mock_course_overview.return_value = mocked_course_overview
mock_course_runs.return_value = [
{
'key': str(mocked_course_overview.id),
'enrollment_end': str(mocked_course_overview.enrollment_end),
'pacing_type': 'self_paced',
'type': 'verified',
'status': 'published'
}
]
# response = self.client.get(self.path)
# self.assertNotIn(noAvailableSessions, response.content)
# Test an enrollment end that doesn't exist sets an availableSession
mocked_course_overview.enrollment_end = None
mocked_course_overview.save()
mock_course_overview.return_value = mocked_course_overview
mock_course_runs.return_value = [
{
'key': str(mocked_course_overview.id),
'enrollment_end': None,
'pacing_type': 'self_paced',
'type': 'verified',
'status': 'published'
}
]
def test_sessions_for_entitlement_course_runs(self, mock_course_key,
mock_course_overview,
mock_course_runs):
"""
When a learner has a fulfilled entitlement for a course run in the past, there should be no availableSession
data passed to the JS view. When a learner has a fulfilled entitlement for a course run enrollment ending in the
future, there should not be an empty availableSession variable. When a learner has a fulfilled entitlement
for a course that doesn't have an enrollment ending, there should not be an empty availableSession variable.
"""
# Test an enrollment end in the past
mocked_course_overview = CourseOverviewFactory.create(
start=self.TOMORROW,
self_paced=True,
enrollment_end=self.THREE_YEARS_AGO)
mock_course_overview.return_value = mocked_course_overview
mock_course_key.return_value = mocked_course_overview.id
course_enrollment = CourseEnrollmentFactory(
user=self.user, course_id=unicode(mocked_course_overview.id))
mock_course_runs.return_value = [{
'key':
mocked_course_overview.id,
'enrollment_end':
mocked_course_overview.enrollment_end,
'pacing_type':
'self_paced',
'type':
'verified'
}]
CourseEntitlementFactory(user=self.user,
enrollment_course_run=course_enrollment)
response = self.client.get(self.path)
self.assertIn("availableSessions: '[]'", response.content)
# Test an enrollment end in the future sets an availableSession
mocked_course_overview.enrollment_end = self.TOMORROW
mocked_course_overview.save()
mock_course_overview.return_value = mocked_course_overview
mock_course_key.return_value = mocked_course_overview.id
mock_course_runs.return_value = [{
'key':
mocked_course_overview.id,
'enrollment_end':
mocked_course_overview.enrollment_end,
'pacing_type':
'self_paced',
'type':
'verified'
}]
response = self.client.get(self.path)
self.assertNotIn("availableSessions: '[]'", response.content)
# Test an enrollment end that doesn't exist sets an availableSession
mocked_course_overview.enrollment_end = None
mocked_course_overview.save()
mock_course_overview.return_value = mocked_course_overview
mock_course_key.return_value = mocked_course_overview.id
mock_course_runs.return_value = [{
'key':
mocked_course_overview.id,
'enrollment_end':
mocked_course_overview.enrollment_end,
'pacing_type':
'self_paced',
'type':
'verified'
}]
response = self.client.get(self.path)
self.assertNotIn("availableSessions: '[]'", response.content)
