def test_remove_team_registrations_and_cancel_scheduled_reminders(
registered_email, team_email, expected_reminders_cancelled, webinar, mocker
):
"""
Test that the is_team_member_registration is marked False successfully for all the given members
"""
mocked_cancel_all_reminders = mocker.patch('openedx.adg.lms.webinars.models.cancel_all_reminders')
total_emails = []
if registered_email:
total_emails.append(registered_email)
WebinarRegistrationFactory(email=registered_email, webinar=webinar, is_registered=True)
if team_email:
total_emails.append(team_email)
WebinarRegistrationFactory(
email=team_email, webinar=webinar, is_registered=False, is_team_member_registration=True
)
registrations = WebinarRegistration.remove_team_registrations_and_cancel_scheduled_reminders(total_emails, webinar)
(cancelled_registrations,) = mocked_cancel_all_reminders.call_args.args
cancelled_reminder_email_addresses = cancelled_registrations.values_list('email', flat=True)
assert sorted(cancelled_reminder_email_addresses) == sorted(expected_reminders_cancelled)
assert not any(registrations.values_list('is_team_member_registration', flat=True))
def test_create_team_registrations_and_schedule_reminder(
registered_email, team_email, expected_reminders_scheduled, webinar, mocker
):
"""
Test that the team registrations are created for the given emails successfully
"""
mocked_schedule_webinar_reminders = mocker.patch('openedx.adg.lms.webinars.models.schedule_webinar_reminders')
total_emails = []
if registered_email:
total_emails.append(registered_email)
WebinarRegistrationFactory(email=registered_email, webinar=webinar, is_registered=True)
if team_email:
total_emails.append(team_email)
WebinarRegistrationFactory(
email=team_email, webinar=webinar, is_registered=False, is_team_member_registration=True
)
WebinarRegistration.create_team_registrations_and_schedule_reminder(total_emails, webinar)
scheduled_reminder_email_addresses, _ = mocked_schedule_webinar_reminders.call_args.args
assert sorted(scheduled_reminder_email_addresses) == sorted(expected_reminders_scheduled)
assert all(WebinarRegistration.objects.filter(email__in=total_emails).values_list(
'is_team_member_registration', flat=True)
)
def test_send_cancellation_emails_for_given_webinars(
mocker, registered_users_with_response, team_member, expected_email_addresses, webinar
):
"""
Test if emails are sent to all the registered users without any duplicates
"""
mocked_send_mandrill_email = mocker.patch('openedx.adg.lms.webinars.helpers.task_send_mandrill_email')
email, invite_response = registered_users_with_response
WebinarRegistrationFactory(email=email, webinar=webinar, is_registered=invite_response)
if team_member:
WebinarRegistrationFactory(email=team_member, webinar=webinar, is_team_member_registration=True)
send_cancellation_emails_for_given_webinars([webinar])
expected_context = {
'webinar_id': webinar.id,
'webinar_title': webinar.title,
'webinar_description': webinar.description,
'webinar_start_time': webinar.start_date_time_AST,
'webinar_link': webinar.meeting_link,
}
if expected_email_addresses:
actual_template, actual_email_addresses, actual_context, _ = mocked_send_mandrill_email.delay.call_args.args
assert actual_template == MandrillClient.WEBINAR_CANCELLATION
assert actual_context == expected_context
assert sorted(actual_email_addresses) == sorted(expected_email_addresses)
else:
mocked_send_mandrill_email.assert_not_called()
def test_update_all_webinar_registrations_to_new_email():
"""
Test that the registrations are updated successfully
"""
old_email = '*****@*****.**'
new_email = '*****@*****.**'
total_registrations = 5
WebinarRegistrationFactory.create_batch(total_registrations, email=old_email)
update_all_webinar_registrations_to_new_email(old_email, new_email)
assert WebinarRegistration.objects.filter(email=new_email).count() == total_registrations
assert WebinarRegistration.objects.filter(email=old_email).count() == 0
def test_cancel_reminder_emails(mocker, is_registered,
is_team_member_registration,
expected_call_count):
"""
Test that upon deleting webinar registration, reminder emails of a registered user
or a webinar team member are cancelled
"""
mock_cancel_all_reminders = mocker.patch(
'openedx.adg.lms.webinars.handlers.cancel_all_reminders')
registration = WebinarRegistrationFactory(
is_registered=is_registered,
is_team_member_registration=is_team_member_registration)
registration.delete()
assert mock_cancel_all_reminders.call_count == expected_call_count
def test_webinar_registration_view_register_user_with_prior_registration(
action, user_client, is_registered, mocker):
"""
Test webinar registration and cancellation if webinar was previously registered or canceled by user
"""
mock_send_registration_email = mocker.patch(
'openedx.adg.lms.webinars.api.views.send_webinar_registration_email')
user, client = user_client
registration = WebinarRegistrationFactory(email=user.email,
is_registered=is_registered)
response = client.post(
reverse('webinars_api:webinar_registration',
kwargs={
'pk': registration.webinar.id,
'action': action
}))
expected_registration = WebinarRegistration.objects.filter(
webinar=registration.webinar, email=user.email).first()
assert expected_registration.is_registered == (action == 'register')
if action == 'register' and not is_registered:
mock_send_registration_email.assert_called_once_with(
registration.webinar, user.email)
else:
mock_send_registration_email.assert_not_called()
assert response.status_code == HTTP_200_OK
def test_dashboard_view_context_data(user_with_profile, courses, webinar,
mocker, request):
"""
Test dashboard page context data
"""
mocker.patch(
'openedx.adg.lms.student.views.DashboardView.get_filtered_enrolled_courses'
)
mocker.patch('openedx.adg.lms.student.views.get_course_by_id',
return_value=courses['test_course1'])
mocker.patch('openedx.adg.lms.student.views.reverse',
return_value='/account/settings')
dashboard_request = request
user_with_profile.is_active = False
dashboard_request.user = user_with_profile
CourseEnrollment.enroll(user=user_with_profile,
course_key=courses['test_course1'].id)
CourseEnrollment.enroll(user=user_with_profile,
course_key=courses['test_course2'].id)
PersistentCourseGrade.update_or_create(
user_id=user_with_profile.id,
course_id=courses['test_course1'].id,
percent_grade=0.8,
passed=True)
WebinarRegistrationFactory(email=user_with_profile.email,
webinar=webinar,
is_registered=True)
GeneratedCertificateFactory(user=user_with_profile,
course_id=courses['test_course1'].id,
status=CertificateStatuses.downloadable)
context_data = DashboardView(request=dashboard_request).get_context_data()
assert 'user' in context_data
assert 'user_profile' in context_data
assert 'profile_image_url' in context_data
assert 'edit_account_link' in context_data
assert 'application_link' in context_data
assert 'courses' in context_data
assert 'courses_filter_options' in context_data
assert 'courses_filter' in context_data
assert 'webinars' in context_data
assert 'webinars_filter_options' in context_data
assert 'webinars_filter' in context_data
assert 'certificates' in context_data
assert 'activate_account_message' in context_data
assert 'account_activation_messages' in context_data
assert context_data[
'profile_image_url'] == get_profile_image_urls_for_user(
user_with_profile)['full']
assert context_data['edit_account_link'] == '/account/settings'
assert context_data['user'] == user_with_profile
assert len(context_data['webinars']) == 1
def test_update_webinar_team_registrations_and_schedule_reminder_emails(
old_panelists, new_panelists, old_alt_hosts, new_alt_hosts, newly_added_emails, removed_emails, webinar, mocker
): # pylint: disable=protected-access
"""
Test that the `_update_webinar_team_registrations_and_schedule_reminder_emails` adds team member
registrations and schedules reminder emails for newly added team members. And updates the registrations
and cancels scheduled reminders for the removed team members.
"""
mocker.patch('openedx.adg.lms.webinars.models.schedule_webinar_reminders')
mocker.patch('openedx.adg.lms.webinars.models.cancel_all_reminders')
total_emails = newly_added_emails + removed_emails
emails_iter = factory.Iterator(total_emails)
WebinarRegistrationFactory.create_batch(len(total_emails), email=emails_iter, webinar=webinar)
webinar._loaded_values = {
'panelists': old_panelists,
'alternative_hosts': old_alt_hosts,
'is_published': old_panelists or old_alt_hosts
}
webinar.panelists = new_panelists
webinar.alternative_hosts = new_alt_hosts
webinar.save()
webinar._update_webinar_team_registrations()
actual_added_emails = WebinarRegistration.objects.filter(webinar=webinar, email__in=newly_added_emails).values_list(
'is_team_member_registration', flat=True
)
actual_removed_emails = WebinarRegistration.objects.filter(webinar=webinar, email__in=removed_emails).values_list(
'is_team_member_registration', flat=True
)
assert len(actual_added_emails) == len(newly_added_emails)
assert len(actual_removed_emails) == len(removed_emails)
assert all(actual_added_emails)
assert not any(actual_removed_emails)
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_webinar_update_emails(change_field, mocker, webinar, test_team_member_emails):
"""
Test that webinar update emails are sent correctly to all the registered members when
there is a change in webinar contents
"""
mocker.patch('openedx.adg.lms.webinars.models.send_webinar_invitation_emails')
mock_zoom_client = mocker.patch.object(ZoomClient, 'create_webinar')
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,
}
if not test_team_member_emails:
WebinarRegistrationFactory(email=EMAILS[0], webinar=webinar, is_registered=True)
panelists = '*****@*****.**' if test_team_member_emails else ''
values = {
'is_published': True,
'panelists': panelists
}
if change_field:
field, value = change_field
values.update({
field: value
})
webinar._loaded_values = values # pylint: disable=protected-access
webinar.is_published = False
webinar.panelists = panelists
webinar.publish()
expected_email_recipients = (
extract_emails_from_string(panelists) if test_team_member_emails else [EMAILS[0]]
)
mock_send_webinar_emails.assert_called_once_with(
MandrillClient.WEBINAR_UPDATED, webinar, expected_email_recipients
)
def webinar_registration():
return WebinarRegistrationFactory()