def test_course_access_endpoint_with_non_staff_user(self):
user = UserFactory(is_staff=False)
self.client.login(username=user.username, password=UserFactory._DEFAULT_PASSWORD) # lint-amnesty, pylint: disable=protected-access
response = self.client.get(self.url, data=self.request_data)
assert response.status_code == 403
def setUp(self):
super().setUp()
self.catalog_integration = self.create_catalog_integration(cache_ttl=1)
self.user = UserFactory(username=self.catalog_integration.service_username)
def setUp(self):
super(TestCreateDotApplication, self).setUp()
self.user = UserFactory.create()
def setUp(self):
super().setUp()
self.user = UserFactory()
self.client.login(username=self.user.username, password=TEST_PASSWORD)
class StudentDashboardTests(SharedModuleStoreTestCase, MilestonesTestCaseMixin,
CompletionWaffleTestMixin):
"""
Tests for the student dashboard.
"""
EMAIL_SETTINGS_ELEMENT_ID = "#actions-item-email-settings-0"
ENABLED_SIGNALS = ['course_published']
TOMORROW = now() + timedelta(days=1)
THREE_YEARS_FROM_NOW = now() + timedelta(days=(365 * 3))
THREE_YEARS_AGO = now() - timedelta(days=(365 * 3))
MOCK_SETTINGS = {
'FEATURES': {
'DISABLE_START_DATES': False,
'ENABLE_MKTG_SITE': True,
'DISABLE_SET_JWT_COOKIES_FOR_TESTS': True,
},
'SOCIAL_SHARING_SETTINGS': {
'CUSTOM_COURSE_URLS': True,
'DASHBOARD_FACEBOOK': True,
'DASHBOARD_TWITTER': True,
},
}
MOCK_SETTINGS_HIDE_COURSES = {
'FEATURES': {
'HIDE_DASHBOARD_COURSES_UNTIL_ACTIVATED': True,
'DISABLE_SET_JWT_COOKIES_FOR_TESTS': True,
}
}
def setUp(self):
"""
Create a course and user, then log in.
"""
super(StudentDashboardTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.user = UserFactory()
self.client.login(username=self.user.username, password=PASSWORD)
self.path = reverse('dashboard')
def set_course_sharing_urls(self, set_marketing, set_social_sharing):
"""
Set course sharing urls (i.e. social_sharing_url, marketing_url)
"""
course_overview = self.course_enrollment.course_overview
if set_marketing:
course_overview.marketing_url = 'http://www.testurl.com/marketing/url/'
if set_social_sharing:
course_overview.social_sharing_url = 'http://www.testurl.com/social/url/'
course_overview.save()
def test_redirect_account_settings(self):
"""
Verify if user does not have profile he/she is redirected to account_settings.
"""
UserProfile.objects.get(user=self.user).delete()
response = self.client.get(self.path)
self.assertRedirects(response, reverse('account_settings'))
def test_grade_appears_before_course_end_date(self):
"""
Verify that learners are not able to see their final grade before the end
of course in the learner dashboard
"""
self.course_key = CourseKey.from_string(
'course-v1:edX+DemoX+Demo_Course') # lint-amnesty, pylint: disable=attribute-defined-outside-init
self.course = CourseOverviewFactory.create(
id=self.course_key,
end_date=self.TOMORROW, # lint-amnesty, pylint: disable=attribute-defined-outside-init
certificate_available_date=self.THREE_YEARS_AGO,
lowest_passing_grade=0.3)
self.course_enrollment = CourseEnrollmentFactory(
course_id=self.course.id, user=self.user) # lint-amnesty, pylint: disable=attribute-defined-outside-init
GeneratedCertificateFactory(status='notpassing',
course_id=self.course.id,
user=self.user,
grade=0.45)
response = self.client.get(reverse('dashboard'))
# The final grade does not appear before the course has ended
self.assertContains(response, 'Your final grade:')
self.assertContains(response, '<span class="grade-value">45%</span>')
def test_grade_not_appears_before_cert_available_date(self):
"""
Verify that learners are able to see their final grade of the course in
the learner dashboard after the course had ended
"""
self.course_key = CourseKey.from_string(
'course-v1:edX+DemoX+Demo_Course') # lint-amnesty, pylint: disable=attribute-defined-outside-init
self.course = CourseOverviewFactory.create(
id=self.course_key,
end_date=self.THREE_YEARS_AGO, # lint-amnesty, pylint: disable=attribute-defined-outside-init
certificate_available_date=self.TOMORROW,
lowest_passing_grade=0.3)
self.course_enrollment = CourseEnrollmentFactory(
course_id=self.course.id, user=self.user) # lint-amnesty, pylint: disable=attribute-defined-outside-init
GeneratedCertificateFactory(status='notpassing',
course_id=self.course.id,
user=self.user,
grade=0.45)
response = self.client.get(reverse('dashboard'))
self.assertNotContains(response, 'Your final grade:')
self.assertNotContains(response,
'<span class="grade-value">45%</span>')
@patch.multiple('django.conf.settings', **MOCK_SETTINGS)
@ddt.data(*itertools.product(
[True, False],
[True, False],
[ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split],
))
@ddt.unpack
def test_sharing_icons_for_future_course(self, set_marketing,
set_social_sharing,
modulestore_type):
"""
Verify that the course sharing icons show up if course is starting in future and
any of marketing or social sharing urls are set.
"""
self.course = CourseFactory.create(start=self.TOMORROW,
emit_signals=True,
default_store=modulestore_type) # lint-amnesty, pylint: disable=attribute-defined-outside-init
self.course_enrollment = CourseEnrollmentFactory(
course_id=self.course.id, user=self.user) # lint-amnesty, pylint: disable=attribute-defined-outside-init
self.set_course_sharing_urls(set_marketing, set_social_sharing)
# Assert course sharing icons
response = self.client.get(reverse('dashboard'))
assert ('Share on Twitter'
in response.content.decode('utf-8')) == (set_marketing
or set_social_sharing)
assert ('Share on Facebook'
in response.content.decode('utf-8')) == (set_marketing
or set_social_sharing)
@patch.dict("django.conf.settings.FEATURES",
{'ENABLE_PREREQUISITE_COURSES': True})
def test_pre_requisites_appear_on_dashboard(self):
"""
When a course has a prerequisite, the dashboard should display the prerequisite.
If we remove the prerequisite and access the dashboard again, the prerequisite
should not appear.
"""
self.pre_requisite_course = CourseFactory.create(
org='edx', number='999', display_name='Pre requisite Course') # lint-amnesty, pylint: disable=attribute-defined-outside-init
self.course = CourseFactory.create( # lint-amnesty, pylint: disable=attribute-defined-outside-init
org='edx',
number='998',
display_name='Test Course',
pre_requisite_courses=[
six.text_type(self.pre_requisite_course.id)
])
self.course_enrollment = CourseEnrollmentFactory(
course_id=self.course.id, user=self.user) # lint-amnesty, pylint: disable=attribute-defined-outside-init
set_prerequisite_courses(self.course.id,
[six.text_type(self.pre_requisite_course.id)])
response = self.client.get(reverse('dashboard'))
self.assertContains(response, '<div class="prerequisites">')
remove_prerequisite_course(self.course.id,
get_course_milestones(self.course.id)[0])
response = self.client.get(reverse('dashboard'))
self.assertNotContains(response, '<div class="prerequisites">')
@patch('openedx.core.djangoapps.programs.utils.get_programs')
@patch(
'common.djangoapps.student.views.dashboard.get_visible_sessions_for_entitlement'
)
@patch(
'common.djangoapps.student.views.dashboard.get_pseudo_session_for_entitlement'
)
@patch.object(CourseOverview, 'get_from_id')
def test_unfulfilled_entitlement(self, mock_course_overview,
mock_pseudo_session, mock_course_runs,
mock_get_programs):
"""
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
- a related programs message
"""
program = ProgramFactory()
CourseEntitlementFactory.create(
user=self.user, course_uuid=program['courses'][0]['uuid'])
mock_get_programs.return_value = [program]
course_key = CourseKey.from_string('course-v1:FAKE+FA1-MA1.X+3T2017')
mock_course_overview.return_value = CourseOverviewFactory.create(
start=self.TOMORROW, id=course_key)
mock_course_runs.return_value = [{
'key': six.text_type(course_key),
'enrollment_end': str(self.TOMORROW),
'pacing_type': 'instructor_paced',
'type': 'verified',
'status': 'published'
}]
mock_pseudo_session.return_value = {
'key': six.text_type(course_key),
'type': 'verified'
}
response = self.client.get(self.path)
self.assertContains(response,
'class="course-target-link enter-course hidden"')
self.assertContains(response,
'You must select a session to access the course.')
self.assertContains(
response, '<div class="course-entitlement-selection-container ">')
self.assertContains(response, 'Related Programs:')
# If an entitlement has already been redeemed by the user for a course run, do not let the run be selectable
enrollment = CourseEnrollmentFactory(
user=self.user,
course=mock_course_overview.return_value,
mode=CourseMode.VERIFIED)
CourseEntitlementFactory.create(
user=self.user,
course_uuid=program['courses'][0]['uuid'],
enrollment_course_run=enrollment)
mock_course_runs.return_value = [{
'key': 'course-v1:edX+toy+2012_Fall',
'enrollment_end': str(self.TOMORROW),
'pacing_type': 'instructor_paced',
'type': 'verified',
'status': 'published'
}]
response = self.client.get(self.path)
# There should be two entitlements on the course page, one prompting for a mandatory session, but no
# select option for the courses as there is only the single course run which has already been redeemed
self.assertContains(response, '<li class="course-item">', count=2)
self.assertContains(response,
'You must select a session to access the course.')
self.assertNotContains(response,
'To access the course, select a session.')
@patch(
'common.djangoapps.student.views.dashboard.get_visible_sessions_for_entitlement'
)
@patch.object(CourseOverview, 'get_from_id')
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">')
@patch(
'common.djangoapps.entitlements.rest_api.v1.views.get_course_runs_for_course'
)
@patch.object(CourseOverview, 'get_from_id')
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'
}]
# response = self.client.get(self.path)
# self.assertNotIn(noAvailableSessions, response.content)
@patch('openedx.core.djangoapps.programs.utils.get_programs')
@patch(
'common.djangoapps.student.views.dashboard.get_visible_sessions_for_entitlement'
)
@patch.object(CourseOverview, 'get_from_id')
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:')
@patch('openedx.core.djangoapps.programs.utils.get_programs')
@patch(
'common.djangoapps.student.views.dashboard.get_visible_sessions_for_entitlement'
)
@patch.object(CourseOverview, 'get_from_id')
def test_fulfilled_expired_entitlement(self, mock_course_overview,
mock_course_runs,
mock_get_programs):
"""
When a learner has a fulfilled entitlement that is expired, their course dashboard should have:
- exactly one course item, meaning it:
- has an entitlement card
- Message that the learner can no longer change sessions
- 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), created=self.THREE_YEARS_AGO) # lint-amnesty, pylint: disable=line-too-long
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, created=self.THREE_YEARS_AGO) # lint-amnesty, pylint: disable=line-too-long
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, 'You can no longer change sessions.')
self.assertContains(response, 'Related Programs:')
@patch('openedx.core.djangoapps.catalog.utils.get_course_runs_for_course')
@patch(
'common.djangoapps.student.views.dashboard.is_bulk_email_feature_enabled'
)
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, course_id=course_overview.id)
entitlement = CourseEntitlementFactory(
user=self.user, enrollment_course_run=course_enrollment)
course_runs = [{
'key': six.text_type(course_overview.id),
'uuid': entitlement.course_uuid
}]
mock_get_course_runs.return_value = course_runs
response = self.client.get(self.path)
assert pq(response.content)(self.EMAIL_SETTINGS_ELEMENT_ID).length == 1
@patch.object(CourseOverview, 'get_from_id')
@patch(
'common.djangoapps.student.views.dashboard.is_bulk_email_feature_enabled'
)
def test_email_settings_unfulfilled_entitlement(self, mock_email_feature,
mock_course_overview):
"""
Assert that the Email Settings action is not shown when the entitlement is not fulfilled.
"""
mock_email_feature.return_value = True
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
CourseEntitlementFactory(user=self.user)
response = self.client.get(self.path)
assert pq(response.content)(self.EMAIL_SETTINGS_ELEMENT_ID).length == 0
@patch.multiple('django.conf.settings', **MOCK_SETTINGS_HIDE_COURSES)
def test_hide_dashboard_courses_until_activated(self):
"""
Verify that when the HIDE_DASHBOARD_COURSES_UNTIL_ACTIVATED feature is enabled,
inactive users don't see the Courses list, but active users still do.
"""
# Ensure active users see the course list
assert self.user.is_active
response = self.client.get(reverse('dashboard'))
self.assertContains(response,
'You are not enrolled in any courses yet.')
# Ensure inactive users don't see the course list
self.user.is_active = False
self.user.save()
response = self.client.get(reverse('dashboard'))
self.assertNotContains(response,
'You are not enrolled in any courses yet.')
def test_show_empty_dashboard_message(self):
"""
Verify that when the EMPTY_DASHBOARD_MESSAGE feature is set,
its text is displayed in an empty courses list.
"""
empty_dashboard_message = "Check out our lovely <i>free</i> courses!"
response = self.client.get(reverse('dashboard'))
self.assertContains(response,
'You are not enrolled in any courses yet.')
self.assertNotContains(response, empty_dashboard_message)
with with_site_configuration_context(
configuration={
"EMPTY_DASHBOARD_MESSAGE": empty_dashboard_message,
}):
response = self.client.get(reverse('dashboard'))
self.assertContains(response,
'You are not enrolled in any courses yet.')
self.assertContains(response, empty_dashboard_message)
@patch('django.conf.settings.DASHBOARD_COURSE_LIMIT', 1)
def test_course_limit_on_dashboard(self):
course = CourseFactory.create()
CourseEnrollmentFactory(user=self.user, course_id=course.id)
course_v1 = CourseFactory.create()
CourseEnrollmentFactory(user=self.user, course_id=course_v1.id)
response = self.client.get(reverse('dashboard'))
self.assertContains(response, '1 results successfully populated')
@staticmethod
def _remove_whitespace_from_html_string(html):
return ''.join(html.split())
@staticmethod
def _remove_whitespace_from_response(response):
return ''.join(response.content.decode('utf-8').split())
@staticmethod
def _pull_course_run_from_course_key(course_key_string): # lint-amnesty, pylint: disable=missing-function-docstring
search_results = re.search(r'Run_[0-9]+$', course_key_string)
assert search_results
course_run_string = search_results.group(0).replace('_', ' ')
return course_run_string
@staticmethod
def _get_html_for_view_course_button(course_key_string, course_run_string):
return '''
<a href="/courses/{course_key}/course/"
class="course-target-link enter-course"
data-course-key="{course_key}">
View Course
<span class="sr">
{course_run}
</span>
</a>
'''.format(course_key=course_key_string, course_run=course_run_string)
@staticmethod
def _get_html_for_resume_course_button(course_key_string,
resume_block_key_string,
course_run_string):
return '''
<a href="/courses/{course_key}/jump_to/{url_to_block}"
class="course-target-link enter-course"
data-course-key="{course_key}">
Resume Course
<span class="sr">
{course_run}
</span>
</a>
'''.format(course_key=course_key_string,
url_to_block=resume_block_key_string,
course_run=course_run_string)
@staticmethod
def _get_html_for_entitlement_button(course_key_string):
return '''
<div class="course-info">
<span class="info-university">{org} - </span>
<span class="info-course-id">{course}</span>
<span class="info-date-block-container">
<button class="change-session btn-link ">Change or Leave Session</button>
</span>
</div>
'''.format(org=course_key_string.split('/')[0],
course=course_key_string.split('/')[1])
def test_view_course_appears_on_dashboard(self):
"""
When a course doesn't have completion data, its course card should
display a "View Course" button.
"""
self.override_waffle_switch(True)
course = CourseFactory.create()
CourseEnrollmentFactory.create(user=self.user, course_id=course.id)
response = self.client.get(reverse('dashboard'))
course_key_string = str(course.id)
# No completion data means there's no block from which to resume.
resume_block_key_string = ''
course_run_string = self._pull_course_run_from_course_key(
course_key_string)
view_button_html = self._get_html_for_view_course_button(
course_key_string, course_run_string)
resume_button_html = self._get_html_for_resume_course_button(
course_key_string, resume_block_key_string, course_run_string)
view_button_html = self._remove_whitespace_from_html_string(
view_button_html)
resume_button_html = self._remove_whitespace_from_html_string(
resume_button_html)
dashboard_html = self._remove_whitespace_from_response(response)
assert view_button_html in dashboard_html
assert resume_button_html not in dashboard_html
def test_resume_course_appears_on_dashboard(self):
"""
When a course has completion data, its course card should display a
"Resume Course" button.
"""
self.override_waffle_switch(True)
course = CourseFactory.create()
CourseEnrollmentFactory.create(user=self.user, course_id=course.id)
course_key = course.id
block_keys = [
ItemFactory.create(category='video',
parent_location=course.location,
display_name='Video {0}'.format(
six.text_type(number))).location
for number in range(5)
]
submit_completions_for_testing(self.user, block_keys)
response = self.client.get(reverse('dashboard'))
course_key_string = str(course_key)
resume_block_key_string = str(block_keys[-1])
course_run_string = self._pull_course_run_from_course_key(
course_key_string)
view_button_html = self._get_html_for_view_course_button(
course_key_string, course_run_string)
resume_button_html = self._get_html_for_resume_course_button(
course_key_string, resume_block_key_string, course_run_string)
view_button_html = self._remove_whitespace_from_html_string(
view_button_html)
resume_button_html = self._remove_whitespace_from_html_string(
resume_button_html)
dashboard_html = self._remove_whitespace_from_response(response)
assert resume_button_html in dashboard_html
assert view_button_html not in dashboard_html
def test_content_gating_course_card_changes(self):
"""
When a course is expired, the links on the course card should be removed.
Links will be removed from the course title, course image and button (View Course/Resume Course).
The course card should have an access expired message.
"""
CourseDurationLimitConfig.objects.create(
enabled=True,
enabled_as_of=self.THREE_YEARS_AGO - timedelta(days=30))
self.override_waffle_switch(True)
course = CourseFactory.create(start=self.THREE_YEARS_AGO)
add_course_mode(course, mode_slug=CourseMode.AUDIT)
add_course_mode(course)
enrollment = CourseEnrollmentFactory.create(user=self.user,
course_id=course.id)
enrollment.created = self.THREE_YEARS_AGO + timedelta(days=1)
enrollment.save()
response = self.client.get(reverse('dashboard'))
dashboard_html = self._remove_whitespace_from_response(response)
access_expired_substring = 'Accessexpired'
course_link_class = 'course-target-link'
assert course_link_class not in dashboard_html
assert access_expired_substring in dashboard_html
def test_dashboard_with_resume_buttons_and_view_buttons(self):
'''
The Test creates a four-course-card dashboard. The user completes course
blocks in the even-numbered course cards. The test checks that courses
with completion data have course cards with "Resume Course" buttons;
those without have "View Course" buttons.
'''
self.override_waffle_switch(True)
isEven = lambda n: n % 2 == 0
num_course_cards = 4
html_for_view_buttons = []
html_for_resume_buttons = []
html_for_entitlement = []
for i in range(num_course_cards):
course = CourseFactory.create()
course_enrollment = CourseEnrollmentFactory(user=self.user,
course_id=course.id)
course_key = course_enrollment.course_id
course_key_string = str(course_key)
if i == 1:
CourseEntitlementFactory.create(
user=self.user, enrollment_course_run=course_enrollment)
else:
last_completed_block_string = ''
course_run_string = self._pull_course_run_from_course_key(
course_key_string)
# Submit completed course blocks in even-numbered courses.
if isEven(i):
block_keys = [
ItemFactory.create(category='video',
parent_location=course.location,
display_name='Video {0}'.format(
six.text_type(number))).location
for number in range(5)
]
last_completed_block_string = str(block_keys[-1])
submit_completions_for_testing(self.user, block_keys)
html_for_view_buttons.append(
self._get_html_for_view_course_button(course_key_string,
course_run_string))
html_for_resume_buttons.append(
self._get_html_for_resume_course_button(
course_key_string, last_completed_block_string,
course_run_string))
html_for_entitlement.append(
self._get_html_for_entitlement_button(course_key_string))
response = self.client.get(reverse('dashboard'))
html_for_view_buttons = [
self._remove_whitespace_from_html_string(button)
for button in html_for_view_buttons
]
html_for_resume_buttons = [
self._remove_whitespace_from_html_string(button)
for button in html_for_resume_buttons
]
html_for_entitlement = [
self._remove_whitespace_from_html_string(button)
for button in html_for_entitlement
]
dashboard_html = self._remove_whitespace_from_response(response)
for i in range(num_course_cards):
expected_button = None
unexpected_button = None
if i == 1:
expected_button = html_for_entitlement[i]
unexpected_button = html_for_view_buttons[
i] + html_for_resume_buttons[i]
elif isEven(i):
expected_button = html_for_resume_buttons[i]
unexpected_button = html_for_view_buttons[
i] + html_for_entitlement[i]
else:
expected_button = html_for_view_buttons[i]
unexpected_button = html_for_resume_buttons[
i] + html_for_entitlement[i]
assert expected_button in dashboard_html
assert unexpected_button not in dashboard_html
def setUpClass(cls):
super(EnrollmentTrackPartitionSchemeTest, cls).setUpClass()
cls.course = CourseFactory.create()
cls.student = UserFactory()
def test_duplicate_email(self):
UserFactory.create(email=self.pending_change_request.new_email)
self.check_confirm_email_change('email_exists.html', {})
self.assertFailedBeforeEmailing()
def setUp(self):
super().setUp()
self.org = 'testX'
self.course = CourseFactory.create(org=self.org)
self.users = UserFactory.create_batch(5)
CourseOverview.load_from_module_store(self.course.id)
def _setup_user(self):
self.user = UserFactory.create()
CourseEnrollment.enroll(self.user, self.course_key)
def setUp(self):
super().setUp()
self.service_user = UserFactory(username=self.SERVICE_USERNAME)
self.url = reverse("username_replacement")
def create_user(self):
"""
Creates a normal student user.
"""
return UserFactory()
def setUp(self):
super().setUp()
self.client = APIClient()
self.user = UserFactory.create(password=TEST_PASSWORD)
self.url = reverse("accounts_api", kwargs={'username': self.user.username})
def test_cohort_membership_changed(self, mock_tracker):
cohort_list = [CohortFactory() for _ in range(2)]
non_cohort = CourseUserGroup.objects.create(
name="dummy",
course_id=self.course_key,
group_type="dummy"
)
user_list = [UserFactory() for _ in range(2)]
mock_tracker.reset_mock()
def assert_events(event_name_suffix, user_list, cohort_list):
"""
Confirms the presence of the specifed event for each user in the specified list of cohorts
"""
expected_calls = [
call(
"edx.cohort.user_" + event_name_suffix,
{
"user_id": user.id,
"cohort_id": cohort.id,
"cohort_name": cohort.name,
}
)
for user in user_list for cohort in cohort_list
]
mock_tracker.emit.assert_has_calls(expected_calls, any_order=True)
# Add users to cohort
cohort_list[0].users.add(*user_list)
assert_events("added", user_list, cohort_list[:1])
mock_tracker.reset_mock()
# Remove users from cohort
cohort_list[0].users.remove(*user_list)
assert_events("removed", user_list, cohort_list[:1])
mock_tracker.reset_mock()
# Clear users from cohort
cohort_list[0].users.add(*user_list)
cohort_list[0].users.clear()
assert_events("removed", user_list, cohort_list[:1])
mock_tracker.reset_mock()
# Clear users from non-cohort group
non_cohort.users.add(*user_list)
non_cohort.users.clear()
self.assertFalse(mock_tracker.emit.called)
# Add cohorts to user
user_list[0].course_groups.add(*cohort_list)
assert_events("added", user_list[:1], cohort_list)
mock_tracker.reset_mock()
# Remove cohorts from user
user_list[0].course_groups.remove(*cohort_list)
assert_events("removed", user_list[:1], cohort_list)
mock_tracker.reset_mock()
# Clear cohorts from user
user_list[0].course_groups.add(*cohort_list)
user_list[0].course_groups.clear()
assert_events("removed", user_list[:1], cohort_list)
mock_tracker.reset_mock()
# Clear non-cohort groups from user
user_list[0].course_groups.add(non_cohort)
user_list[0].course_groups.clear()
self.assertFalse(mock_tracker.emit.called)
def test_add_user_to_cohort(self, mock_signal, mock_tracker):
"""
Make sure cohorts.add_user_to_cohort() properly adds a user to a cohort and
handles errors.
"""
course_user = UserFactory(username="******", email="*****@*****.**")
UserFactory(username="******", email="*****@*****.**")
course = modulestore().get_course(self.toy_course_key)
CourseEnrollment.enroll(course_user, self.toy_course_key)
first_cohort = CohortFactory(course_id=course.id, name="FirstCohort")
second_cohort = CohortFactory(course_id=course.id, name="SecondCohort")
def check_and_reset_signal():
mock_signal.send.assert_called_with(sender=None, user=course_user, course_key=self.toy_course_key)
mock_signal.reset_mock()
# Success cases
# We shouldn't get back a previous cohort, since the user wasn't in one
self.assertEqual(
cohorts.add_user_to_cohort(first_cohort, "Username"),
(course_user, None, False)
)
mock_tracker.emit.assert_any_call(
"edx.cohort.user_add_requested",
{
"user_id": course_user.id,
"cohort_id": first_cohort.id,
"cohort_name": first_cohort.name,
"previous_cohort_id": None,
"previous_cohort_name": None,
}
)
check_and_reset_signal()
# Should get (user, previous_cohort_name) when moved from one cohort to
# another
self.assertEqual(
cohorts.add_user_to_cohort(second_cohort, "Username"),
(course_user, "FirstCohort", False)
)
mock_tracker.emit.assert_any_call(
"edx.cohort.user_add_requested",
{
"user_id": course_user.id,
"cohort_id": second_cohort.id,
"cohort_name": second_cohort.name,
"previous_cohort_id": first_cohort.id,
"previous_cohort_name": first_cohort.name,
}
)
check_and_reset_signal()
# Should preregister email address for a cohort if an email address
# not associated with a user is added
(user, previous_cohort, prereg) = cohorts.add_user_to_cohort(first_cohort, "*****@*****.**")
self.assertEqual(
(user, previous_cohort, prereg),
(None, None, True)
)
mock_tracker.emit.assert_any_call(
"edx.cohort.email_address_preassigned",
{
"user_email": "*****@*****.**",
"cohort_id": first_cohort.id,
"cohort_name": first_cohort.name,
}
)
# Error cases
# Should get ValueError if user already in cohort
self.assertRaises(
ValueError,
lambda: cohorts.add_user_to_cohort(second_cohort, "Username")
)
# UserDoesNotExist if user truly does not exist
self.assertRaises(
User.DoesNotExist,
lambda: cohorts.add_user_to_cohort(first_cohort, "non_existent_username")
)
def test_success_no_enrollment(self):
"""
Basic success path for users who have no enrollments, should simply not error
"""
user = UserFactory()
_listen_for_lms_retire(sender=self.__class__, user=user)
def setUpTestData(cls):
"""Set up and enroll our fake user in the course."""
cls.user = UserFactory(password=TEST_PASSWORD)
CourseEnrollment.enroll(cls.user, cls.course.id)
def setUp(self):
super(UserAssertionTestCase, self).setUp()
self.course = CourseFactory.create()
self.user = UserFactory.create()
# Password defined by factory.
self.client.login(username=self.user.username, password='******')
def setUp(self):
super(TestAccountAPITransactions, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.client = APIClient()
self.user = UserFactory.create(password=TEST_PASSWORD)
self.url = reverse("accounts_api", kwargs={'username': self.user.username})
def setUp(self):
super().setUp()
self.course = None
self.user = UserFactory()
def setUp(self):
super(UsernameReplacementViewTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.service_user = UserFactory(username=self.SERVICE_USERNAME)
self.url = reverse("username_replacement")
def _create_user(self, is_superuser=False, is_staff=False):
return UserFactory(username='******',
is_superuser=is_superuser,
is_staff=is_staff)
def setUp(self):
super(UserProfilePropertiesTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.user = UserFactory.create(password=self.password)
self.profile = self.user.profile
def setUpClass(cls):
super().setUpClass()
cls.command = 'create_api_access_request'
cls.user = UserFactory()
def setUpTestData(cls):
cls.user = UserFactory.create(password='******')
super().setUpTestData()
def setUp(self):
super().setUp()
self.catalog_integration = self.create_catalog_integration(cache_ttl=1)
self.user = UserFactory(username=self.catalog_integration.service_username)
self.tomorrow = now() + timedelta(days=1)
def setUpTestData(cls): # lint-amnesty, pylint: disable=super-method-not-called
"""Set up and enroll our fake user in the course."""
cls.user = UserFactory(password=TEST_PASSWORD)
CourseEnrollment.enroll(cls.user, cls.course.id)
cls.site = Site.objects.get_current()
class PermissionTests(ModuleStoreTestCase):
"""
Tests for permissions defined in courseware.rules
"""
def setUp(self):
super().setUp()
self.user = UserFactory()
self.course = CourseFactory(enable_proctored_exams=True)
self.course_id = self.course.id # pylint: disable=no-member
CourseModeFactory(mode_slug='verified', course_id=self.course_id)
CourseModeFactory(mode_slug='masters', course_id=self.course_id)
CourseModeFactory(mode_slug='professional', course_id=self.course_id)
CourseEnrollment.unenroll(self.user, self.course_id)
def tearDown(self):
super().tearDown()
self.user.delete()
@ddt.data(
('audit', False),
('verified', True),
('masters', True),
('professional', True),
('no-id-professional', False),
)
@ddt.unpack
def test_proctoring_perm(self, mode, should_have_perm):
"""
Test that the user has the edx_proctoring.can_take_proctored_exam permission
"""
if mode is not None:
CourseEnrollment.enroll(self.user, self.course_id, mode=mode)
has_perm = self.user.has_perm('edx_proctoring.can_take_proctored_exam',
{'course_id': str(self.course_id)})
assert has_perm == should_have_perm
def test_proctoring_perm_no_enrollment(self):
"""
Test that the user does not have the edx_proctoring.can_take_proctored_exam permission if they
are not enrolled in the course
"""
has_perm = self.user.has_perm('edx_proctoring.can_take_proctored_exam',
{'course_id': str(self.course_id)})
assert not has_perm
@patch.dict(
'django.conf.settings.PROCTORING_BACKENDS',
{'mock_proctoring_allow_honor_mode': {
'allow_honor_mode': True
}})
def test_proctoring_perm_with_honor_mode_permission(self):
"""
Test that the user has the edx_proctoring.can_take_proctored_exam permission in honor enrollment mode.
If proctoring backend configuration allows exam in honor mode {`allow_honor_mode`: True} the user is
granted proctored exam permission.
"""
course_allow_honor = CourseFactory(
enable_proctored_exams=True,
proctoring_provider='mock_proctoring_allow_honor_mode')
CourseEnrollment.enroll(self.user, course_allow_honor.id, mode='honor')
assert self.user.has_perm(
'edx_proctoring.can_take_proctored_exam', {
'course_id': str(course_allow_honor.id),
'backend': 'mock_proctoring_allow_honor_mode',
'is_proctored': True
})
def super_user_object():
"""
Fixture which returns a superuser.
"""
return UserFactory(is_superuser=True, is_staff=True)
def setUp(self):
"""
Fixtures
"""
super(TestRequireStudentIdentifier, self).setUp()
self.student = UserFactory.create()
def test_oauth2_provider_edit_icon_image(self):
"""
Test that we can update an OAuth provider's icon image from the admin
form.
OAuth providers are updated using KeyedConfigurationModelAdmin, which
updates models by adding a new instance that replaces the old one,
instead of editing the old instance directly.
Updating the icon image is tricky here because
KeyedConfigurationModelAdmin copies data over from the previous
version by injecting its attributes into request.GET, but the icon
ends up in request.FILES. We need to ensure that the value is
prepopulated correctly, and that we can clear and update the image.
"""
# Login as a super user
user = UserFactory.create(is_staff=True, is_superuser=True)
user.save()
self.client.login(username=user.username, password='******')
# Get baseline provider count
providers = OAuth2ProviderConfig.objects.all()
pcount = len(providers)
# Create a provider
provider1 = self.configure_dummy_provider(
enabled=True,
icon_class='',
icon_image=SimpleUploadedFile(
'icon.svg', b'<svg><rect width="50" height="100"/></svg>'),
)
# Get the provider instance with active flag
providers = OAuth2ProviderConfig.objects.all()
self.assertEqual(len(providers), 1)
self.assertEqual(providers[pcount].id, provider1.id)
# Edit the provider via the admin edit link
admin = OAuth2ProviderConfigAdmin(provider1, AdminSite())
update_url = reverse('admin:{}_{}_add'.format(
admin.model._meta.app_label, admin.model._meta.model_name))
update_url += "?source={}".format(provider1.pk)
# Remove the icon_image from the POST data, to simulate unchanged icon_image
post_data = models.model_to_dict(provider1)
del post_data['icon_image']
# Remove max_session_length and organization. A default null value must be POSTed
# back as an absent value, rather than as a "null-like" included value.
del post_data['max_session_length']
del post_data['organization']
# Change the name, to verify POST
post_data['name'] = 'Another name'
# Post the edit form: expecting redirect
response = self.client.post(update_url, post_data)
self.assertEqual(response.status_code, 302)
# Editing the existing provider creates a new provider instance
providers = OAuth2ProviderConfig.objects.all()
self.assertEqual(len(providers), pcount + 2)
self.assertEqual(providers[pcount].id, provider1.id)
provider2 = providers[pcount + 1]
# Ensure the icon_image was preserved on the new provider instance
self.assertEqual(provider2.icon_image, provider1.icon_image)
self.assertEqual(provider2.name, post_data['name'])
