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()