def test_other_bu_admin_cannot_get_course_grades(course, mocker, user_with_profile, course_grades_get_request):
"""
Test bu admin of another bu cannot can access `CourseGradeListView`.
"""
mocker.patch(
'openedx.adg.admin_dashboard.performance.views.CourseGradeListView._get_course',
return_value=course
)
mocker.patch(
'openedx.adg.admin_dashboard.performance.views.CourseKey.from_string',
return_value=course.id
)
business_line = BusinessLineFactory()
course_group = MultilingualCourseGroupFactory(
is_program_prerequisite=False, business_line_prerequisite=business_line
)
MultilingualCourseFactory(course=course, multilingual_course_group=course_group)
business_line2 = BusinessLineFactory()
user_with_profile.is_staff = True
user_with_profile.save()
user_with_profile.groups.add(Group.objects.get(name=business_line2.title))
course_grades_get_request.user = user_with_profile
kwargs = {'course_key_string': course.id}
response = CourseGradeListView.as_view()(course_grades_get_request, **kwargs)
assert response.status_code == 403
def test_delete_user_group_with_business_line():
"""
Assert that user group is deleted when existing business line is deleted
"""
business_line = BusinessLineFactory()
business_line.delete()
assert not Group.objects.filter(name=business_line.title).exists()
def test_has_access_to_application(user_with_profile, adg_admin, user_type, expected_result, super_user):
"""
Tests `has_access_to_application` returns expected result for different types of users.
"""
bu = BusinessLineFactory()
application = UserApplicationFactory()
user = user_with_profile
if user_type == 'bu_admin':
application.business_line = bu
application.save()
group = GroupFactory(name=bu.title)
user_with_profile.groups.add(group)
elif user_type == 'other_bu_admin':
bu2 = BusinessLineFactory()
group = GroupFactory(name=bu2.title)
user_with_profile.groups.add(group)
elif user_type == 'adg_admin':
user = adg_admin
elif user_type == 'superuser':
user = super_user
assert has_access_to_application(user, application) == expected_result
def test_modify_user_group_with_business_line():
"""
Assert that user group is modified when existing business line is updated
"""
business_line = BusinessLineFactory()
business_line.title = 'bar'
business_line.save()
assert Group.objects.filter(name=business_line.title).exists()
def test_get_invitee_recipients_for_invitation_emails(
old_invites_by_email,
new_invites_by_email,
old_cohort,
new_cohort,
cohort_users,
is_already_published,
registered_emails,
expected_emails,
webinar
):
"""
Tests that `get_invitee_recipients_for_invitation_emails` returns expected invitee emails.
"""
old_webinar_data = {
'title': webinar.title,
'description': webinar.description,
'start_time': webinar.start_time,
'is_published': is_already_published,
'panelists': '',
'alternative_hosts': '',
'invites_by_email_address': old_invites_by_email,
'invited_user_cohort': old_cohort
}
webinar._loaded_values = old_webinar_data # pylint: disable=protected-access
webinar.invites_by_email_address = new_invites_by_email
webinar.invited_user_cohort = new_cohort
webinar.save()
BusinessLineFactory(title=old_cohort)
business_line = BusinessLineFactory(title=new_cohort)
if new_cohort != INVITE_ALL_USERS:
for email in cohort_users:
user = UserFactory(email=email)
UserApplicationFactory(business_line=business_line, user=user)
else:
for email in cohort_users:
UserFactory(email=email)
for email in registered_emails:
WebinarRegistrationFactory(email=email, webinar=webinar)
actual_team_emails = webinar.get_invitee_recipients_for_invitation_emails(False)
if new_cohort == INVITE_ALL_USERS:
expected_emails.append(webinar.created_by.email)
assert sorted(list(actual_team_emails)) == sorted(expected_emails)
def test_get_context_data_performance_tracking_view(mocked_get_data_for_all_course_groups, adg_admin, request_factory):
"""
Tests get_context_data method of the performance tracking view
"""
mocked_get_data_for_all_course_groups.return_value = 'chart_data'
course = CourseOverviewFactory()
business_line = BusinessLineFactory()
course_group = MultilingualCourseGroupFactory(business_line_prerequisite=business_line)
MultilingualCourseFactory(course=course, multilingual_course_group=course_group)
course2 = CourseOverviewFactory()
course_group2 = MultilingualCourseGroupFactory(is_common_business_line_prerequisite=True)
MultilingualCourseFactory(course=course2, multilingual_course_group=course_group2)
request = request_factory.get(reverse('performance-tracking'))
request.user = adg_admin
kwargs = {'business-line': ALL_BUSINESS_UNITS}
response = PerformanceTrackingView.as_view()(request, **kwargs)
assert response.context_data.get('has_adg_admin_permissions')
assert response.context_data.get('business_lines') == [ALL_BUSINESS_UNITS, business_line.title]
assert response.context_data.get('selected_business_line') == ALL_BUSINESS_UNITS
assert response.context_data.get('accepted_students') == 0
assert response.context_data.get('program_completions') == 0
assert response.context_data.get('chart') == 'chart_data'
def test_get_business_lines(has_adg_admin_permissions, business_line_selected_by_user, request):
"""
Test that the 'get_business_lines' method returns all business lines or the selected business line
for ADG admin and for BU admin it only returns the business line of which he is admin.
"""
total_business_lines = 2
business_lines = BusinessLineFactory.create_batch(total_business_lines)
request.user = UserFactory()
if not has_adg_admin_permissions:
group = Group.objects.filter(name=business_lines[0].title).first()
request.user.groups.add(group)
elif has_adg_admin_permissions and not business_line_selected_by_user:
business_line_selected_by_user = business_lines[0].title
actual_business_line = PerformanceTrackingView(
has_adg_admin_permissions=has_adg_admin_permissions,
business_line_selected_by_user=business_line_selected_by_user,
request=request
).get_business_lines()
if has_adg_admin_permissions and business_line_selected_by_user == ALL_BUSINESS_UNITS:
assert len(actual_business_line) == total_business_lines
else:
assert len(actual_business_line) == 1
def test_bu_admin_can_get_course_grades(course, mocker, user_with_profile, course_grades_get_request):
"""
Test bu admin can access `CourseGradeListView`.
"""
mocker.patch(
'openedx.adg.admin_dashboard.performance.views.CourseGradeListView._get_course',
return_value=course
)
mocker.patch(
'openedx.adg.admin_dashboard.performance.views.CourseKey.from_string',
return_value=course.id
)
business_line = BusinessLineFactory()
course_group = MultilingualCourseGroupFactory(business_line_prerequisite=business_line)
MultilingualCourseFactory(course=course, multilingual_course_group=course_group)
user_with_profile.is_staff = True
user_with_profile.save()
user_with_profile.groups.add(Group.objects.get(name=business_line.title))
course_grades_get_request.user = user_with_profile
kwargs = {'course_key_string': course.id}
response = CourseGradeListView.as_view()(course_grades_get_request, **kwargs)
assert response.status_code == 200
assert 'object_list' in response.context_data
assert response.context_data.get('course_name') == course.display_name
def test_add_registration_form_defaults(mocker):
"""
Tests that `add_registration_form_defaults` adds default values to registration form fields.
"""
is_testing_environment = mocker.patch('openedx.adg.lms.registration_extension.forms.is_testing_environment')
is_testing_environment.return_value = False
business_line = BusinessLineFactory()
invitation_obj = InvitationFactory(email='*****@*****.**', status=1, business_unit=business_line)
request = RequestFactory().get('/register', data={'email': invitation_obj.email})
mocked_form_desc = MagicMock(fields=[
{'name': 'email', 'restrictions': {}, 'defaultValue': ''},
{'name': 'is_adg_employee', 'defaultValue': ''},
{'name': 'company', 'options': [{'value': business_line.title, 'default': ''}]}
])
form_desc = add_registration_form_defaults(request, mocked_form_desc)
for form in form_desc.fields:
if form['name'] == 'email':
assert form['defaultValue'] == '*****@*****.**'
elif form['name'] == 'is_adg_employee':
assert form['defaultValue']
elif form['name'] == 'company':
for option in form['options']:
if option['value'] == business_line.title:
assert option['default']
def test_application_listing_view_get_queryset(search_query, omni_status,
bu_status, business_unit,
adg_admin):
"""
Test that the filtering of the applications works correctly in the `get_quertset` method
of the listing view
"""
for _, application_type in UserApplication.STATUS_CHOICES:
expected_applications = []
if search_query:
user_with_queried_name = UserFactory()
UserProfileFactory(user=user_with_queried_name, name=search_query)
application_with_test_user = UserApplicationFactory(
user=user_with_queried_name, status=application_type)
ApplicationHubFactory(user=application_with_test_user.user,
is_written_application_completed=True)
expected_applications.append(application_with_test_user)
if omni_status:
application_with_omni_status = UserApplicationFactory(
status=application_type)
ApplicationHubFactory(
user=application_with_omni_status.user,
program_prereq_courses_status=int(omni_status[0]),
is_written_application_completed=True,
)
expected_applications.append(application_with_omni_status)
if bu_status:
application_with_bu_status = UserApplicationFactory(
status=application_type)
ApplicationHubFactory(
user=application_with_bu_status.user,
bu_prereq_courses_status=int(bu_status[0]),
is_written_application_completed=True,
)
expected_applications.append(application_with_bu_status)
if business_unit:
query_business_unit = BusinessLineFactory(title=business_unit[0])
application_with_query_bu = UserApplicationFactory(
status=application_type, business_line=query_business_unit)
ApplicationHubFactory(user=application_with_query_bu.user,
is_written_application_completed=True)
expected_applications = [application_with_query_bu]
listing_view = ApplicationListingView(
application_type=application_type,
query=search_query,
filter_by_business_line=DEFAULT_BUSINESS_LINE_FILTER,
omni_courses_query_values=omni_status,
bu_courses_query_values=bu_status,
business_line_query=business_unit,
is_user_adg_admin=is_superuser_or_adg_admin(adg_admin))
assert list(listing_view.get_queryset()) == list(expected_applications)
def test_webinar_invite_emails_for_initial_publish(
alternative_hosts,
panelists,
invites_by_email_address,
invited_user_cohort,
expected,
business_line,
mocker
):
"""
Test that the webinar invitation emails are sent correctly to all the correct recipients
when a webinar is published for the first time
"""
mocker.patch(
'openedx.adg.lms.webinars.models.Webinar.get_platform_and_non_platform_team_members',
return_value=(set(extract_emails_from_string(alternative_hosts) + extract_emails_from_string(panelists)), set())
)
mocker.patch('openedx.adg.lms.webinars.models.send_webinar_update_emails')
mock_zoom_client = mocker.patch.object(ZoomClient, 'create_webinar')
mock_send_webinar_emails = mocker.patch('openedx.adg.lms.webinars.helpers.send_webinar_emails')
user_a = UserFactory(email='*****@*****.**')
UserApplicationFactory(business_line=BusinessLineFactory(title=BUSINESS_LINE), user=user_a)
user_b = UserFactory(email='*****@*****.**')
UserApplicationFactory(business_line=business_line, user=user_b)
webinar = WebinarFactory(
alternative_hosts=alternative_hosts,
panelists=panelists,
invites_by_email_address=invites_by_email_address,
invited_user_cohort=invited_user_cohort,
is_published=False
)
mock_zoom_client.return_value = {
'join_url': webinar.meeting_link,
'id': webinar.id,
}
webinar.publish()
expected_emails = set(expected)
if invited_user_cohort == INVITE_ALL_USERS:
expected_emails = expected_emails.union(set(User.objects.exclude(email='').values_list('email', flat=True)))
else:
expected_emails = expected_emails.union(set(BusinessLine.user_emails_for_business_line(invited_user_cohort)))
if expected or invited_user_cohort:
template, _, actual_email_addresses = mock_send_webinar_emails.call_args.args
assert template == MandrillClient.WEBINAR_CREATED
assert sorted(list(expected_emails)) == sorted(actual_email_addresses)
else:
mock_send_webinar_emails.assert_not_called()
def test_webinar_invite_emails_for_subsequent_publish_for_invite_cohort_field(
initial_invited_cohort, subsequent_invited_cohort, expected_cohort, business_line, mocker, webinar
): # pylint: disable=protected-access
"""
Test that the webinar invitation emails are sent correctly for all the recipients related
to `invited_user_cohort` field when a webinar is published after the first time
"""
mocker.patch('openedx.adg.lms.webinars.models.send_webinar_update_emails')
mock_zoom_client = mocker.patch.object(ZoomClient, 'create_webinar')
mocker.patch.object(ZoomClient, 'add_panelists')
mock_send_webinar_emails = mocker.patch('openedx.adg.lms.webinars.helpers.send_webinar_emails')
mock_zoom_client.return_value = {
'join_url': webinar.meeting_link,
'id': webinar.id,
}
user_a = UserFactory()
UserApplicationFactory(business_line=BusinessLineFactory(title=BUSINESS_LINE), user=user_a)
user_b = UserFactory()
UserApplicationFactory(business_line=business_line, user=user_b)
webinar._loaded_values = {
'title': webinar.title,
'description': webinar.description,
'start_time': webinar.start_time,
'is_published': True,
'invited_user_cohort': initial_invited_cohort,
'alternative_hosts': '',
'panelists': '',
'invites_by_email_address': ''
}
webinar.invited_user_cohort = subsequent_invited_cohort
webinar.is_published = False
webinar.publish()
all_user_emails = list(User.objects.exclude(email='').values_list('email', flat=True))
selected_bu_emails = list(BusinessLine.user_emails_for_business_line(BUSINESS_LINE))
expected_emails = {
NO_EMAILS: [],
INVITE_ALL_USERS: all_user_emails,
BUSINESS_LINE: selected_bu_emails,
ALL_USERS_EXCEPT_BUSINESS_LINE_USERS: list(set(all_user_emails).difference(set(selected_bu_emails)))
}
if expected_cohort == NO_EMAILS:
mock_send_webinar_emails.assert_not_called()
else:
template, _, actual_email_addresses = mock_send_webinar_emails.call_args.args
assert template == MandrillClient.WEBINAR_CREATED
assert sorted(expected_emails[expected_cohort]) == sorted(actual_email_addresses)
def test_get_submitted_applications(is_superuser, group_name, expected_count):
"""
Test `get_submitted_applications` function for different types of admins.
"""
user_1 = UserFactory()
user_2 = UserFactory()
business_line_1 = BusinessLineFactory(title=BUSINESS_LINE_TEST_NAME_1)
business_line_2 = BusinessLineFactory(title=BUSINESS_LINE_TEST_NAME_2)
ApplicationHubFactory(user=user_1, is_written_application_completed=True)
ApplicationHubFactory(user=user_2, is_written_application_completed=True)
UserApplicationFactory(user=user_1, business_line=business_line_1)
UserApplicationFactory(user=user_2, business_line=business_line_2)
if is_superuser:
admin_user = UserFactory(is_staff=True, is_superuser=True)
else:
admin_user = UserFactory(is_staff=True, groups=[GroupFactory(name=group_name)])
submitted_applications = get_submitted_applications(admin_user)
assert submitted_applications.count() == expected_count
def test_application_dashboard_view_get_request_for_admin(
is_superuser, group_name, request_factory, mocker):
"""
Test get request to ApplicationsDashboardView for an admin user.
"""
request = request_factory.get(reverse('application_hub'))
if group_name == BUSINESS_LINE_TEST_NAME_1:
BusinessLineFactory(title=BUSINESS_LINE_TEST_NAME_1)
if is_superuser:
request.user = UserFactory(is_staff=True, is_superuser=True)
else:
request.user = UserFactory(is_staff=True,
groups=[GroupFactory(name=group_name)])
mocker.patch(
'openedx.adg.admin_dashboard.applications.views.get_new_applications_count_and_percentage_change',
return_value=(0, 0))
mocker.patch(
'openedx.adg.admin_dashboard.applications.views.get_weekly_application_submissions',
return_value='graph_data')
mock_render = mocker.patch(
'openedx.adg.admin_dashboard.applications.views.render')
ApplicationsDashboardView.as_view()(request)
expected_context = {
'total_applications': 0,
'open_applications': 0,
'waitlisted_applications': 0,
'accepted_applications': 0,
'new_applications': 0,
'percentage_change': 0,
'graph_data': 'graph_data'
}
mock_render.assert_called_once_with(
request,
'adg/admin_dashboard/applications/applications_summary.html',
context=expected_context)
def create_admin_accounts(count, account_type, is_active, is_staff=True):
"""
Creates admin accounts using the provided args.
Args:
count (int): Number of accounts
account_type (str): Account type
is_active (bool): Is account active
is_staff (bool): Is staff account
"""
business_line = BusinessLineFactory()
adg_admin_group = GroupFactory(name=ADG_ADMIN_GROUP_NAME)
users = UserFactory.create_batch(count,
is_active=is_active,
is_staff=is_staff)
user_group = adg_admin_group if account_type == ADG_ADMIN else business_line.group
for user in users:
user.groups.add(user_group)
return business_line, adg_admin_group, users, user_group
def test_ensure_admin_user_authentication_mixin_for_different_types_of_users(
is_staff, is_superuser, group_name, has_permission, request_factory):
"""
Test precondition of EnsureAdminUserAuthenticatedMixin for different types of users i.e. non-admin, super-user,
ADG admin and business unit admin.
"""
request = request_factory.get('')
if group_name == BUSINESS_LINE_TEST_NAME_1:
BusinessLineFactory(title=BUSINESS_LINE_TEST_NAME_1)
if is_staff and not is_superuser:
request.user = UserFactory(is_staff=True,
groups=[GroupFactory(name=group_name)])
else:
request.user = UserFactory(is_staff=is_staff,
is_superuser=is_superuser)
test_view = TestView()
test_view.request = request # pylint: disable=attribute-defined-outside-init
assert test_view.is_precondition_satisfied() == has_permission
def test_create_user_group_with_business_line():
"""
Assert that user group is created when new business line is added
"""
business_line = BusinessLineFactory()
assert Group.objects.filter(name=business_line.title).exists()
def business_line():
"""
Fixture to get business line
"""
return BusinessLineFactory()
