def setUpTestData(cls):
super(SearchTests, cls).setUpTestData()
# create some students
with mute_signals(post_save):
cls.students = [(ProfileFactory.create(filled_out=True)).user for _ in range(30)]
# create the programs
cls.program1 = ProgramFactory.create(live=True)
cls.program2 = ProgramFactory.create(live=True)
cls.program3 = ProgramFactory.create(live=True)
# enroll the users in the programs
for num, student in enumerate(cls.students):
if num % 3 == 0:
program = cls.program1
elif num % 3 == 1:
program = cls.program2
else:
program = cls.program3
ProgramEnrollmentFactory.create(
user=student,
program=program
)
# create an user with a role for one program
cls.staff = UserFactory.create()
Role.objects.create(
user=cls.staff,
program=cls.program1,
role=Staff.ROLE_ID
)
# search URL
cls.search_url = reverse('search_api', kwargs={'elastic_url': ''})
def test_financial_aid_with_application_with_full_profile(self):
"""
Test that financialAid request serializer works when profile is filled out.
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
ProgramEnrollmentFactory.create(user=profile.user, program=self.program)
original_currency = 'USD'
original_income = 1000.0
serializer = FinancialAidRequestSerializer(
data={
'program_id': self.program.id,
'tier_program': self.min_tier_program,
'date_documents_sent': None,
'original_currency': original_currency,
'original_income': original_income
},
context={
'request': MagicMock(user=profile.user)
}
)
serializer.is_valid(raise_exception=True)
serializer.save()
assert serializer.data == {
'original_currency': original_currency,
'original_income': original_income,
'program_id': self.program.id
}
def setUpTestData(cls):
super().setUpTestData()
with mute_signals(post_save):
staff_profile = ProfileFactory.create(user__email='*****@*****.**')
recipient_profile = ProfileFactory.create(
user__email='*****@*****.**',
email_optin=True,
)
cls.staff_user = staff_profile.user
cls.recipient_user = recipient_profile.user
cls.program = ProgramFactory.create(financial_aid_availability=False)
ProgramEnrollmentFactory.create(
user=cls.recipient_user,
program=cls.program
)
Role.objects.create(
user=cls.staff_user,
program=cls.program,
role=Staff.ROLE_ID
)
cls.url_name = 'learner_mail_api'
cls.request_data = {
'email_subject': 'email subject',
'email_body': 'email body'
}
def test_multiple_success(self):
"""test retire_users command success with more than one user"""
user_names = ["foo", "bar", "baz"]
for user_name in user_names:
user = UserFactory.create(username=user_name, is_active=True)
user.profile.email_optin = True
user.profile.save()
UserSocialAuthFactory.create(user=user, provider='not_edx')
for _ in range(TOTAL_PROGRAMS):
ProgramEnrollmentFactory.create(user=user)
assert user.is_active is True
assert user.profile.email_optin is True
assert UserSocialAuth.objects.filter(user=user).count() == 1
assert ProgramEnrollment.objects.filter(user=user).count() == TOTAL_PROGRAMS
self.command.handle("retire_users", users=user_names)
for user_name in user_names:
user = User.objects.get(username=user_name)
assert user.is_active is False
assert user.profile.email_optin is False
assert UserSocialAuth.objects.filter(user=user).count() == 0
assert ProgramEnrollment.objects.filter(user=user).count() == 0
def test_financial_aid_with_application_with_full_profile(self):
"""
Test that financialAid request serializer works when profile is filled out.
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
ProgramEnrollmentFactory.create(user=profile.user,
program=self.program)
original_currency = 'USD'
original_income = 1000.0
serializer = FinancialAidRequestSerializer(
data={
'program_id': self.program.id,
'tier_program': self.min_tier_program,
'date_documents_sent': None,
'original_currency': original_currency,
'original_income': original_income
},
context={'request': MagicMock(user=profile.user)})
serializer.is_valid(raise_exception=True)
serializer.save()
assert serializer.data == {
'original_currency': original_currency,
'original_income': original_income,
'program_id': self.program.id
}
def test_learner_view_needs_paid_learner(self, mock_mailgun_client):
"""
Test that a learner attempting to email another learner will only succeed if the sender
has paid for a course run in a program that the recipient is enrolled in
"""
mock_mailgun_client.send_individual_email.return_value = Mock(
spec=Response,
status_code=status.HTTP_200_OK,
json=mocked_json()
)
with mute_signals(post_save):
learner_profile = ProfileFactory.create(
user__email='*****@*****.**',
email_optin=True,
)
learner_user = learner_profile.user
ProgramEnrollmentFactory.create(user=learner_user, program=self.program)
CachedEnrollment.objects.filter(user=learner_user).delete()
self.client.force_login(learner_user)
url = reverse(self.url_name, kwargs={'student_id': self.recipient_user.profile.student_id})
resp_post = self.client.post(url, data=self.request_data, format='json')
assert resp_post.status_code == status.HTTP_403_FORBIDDEN
CachedEnrollmentFactory.create(user=learner_user, course_run__course__program=self.program, verified=True)
resp_post = self.client.post(url, data=self.request_data, format='json')
assert resp_post.status_code == status.HTTP_200_OK
def test_multiple_success(self):
"""test retire_users command success with more than one user"""
user_names = ["foo", "bar", "baz"]
for user_name in user_names:
user = UserFactory.create(username=user_name, is_active=True)
user.profile.email_optin = True
user.profile.save()
UserSocialAuthFactory.create(user=user, provider='not_edx')
for _ in range(TOTAL_PROGRAMS):
ProgramEnrollmentFactory.create(user=user)
assert user.is_active is True
assert user.profile.email_optin is True
assert UserSocialAuth.objects.filter(user=user).count() == 1
assert ProgramEnrollment.objects.filter(
user=user).count() == TOTAL_PROGRAMS
self.command.handle("retire_users", users=user_names)
for user_name in user_names:
user = User.objects.get(username=user_name)
assert user.is_active is False
assert user.profile.email_optin is False
assert UserSocialAuth.objects.filter(user=user).count() == 0
assert ProgramEnrollment.objects.filter(user=user).count() == 0
def test_learner_view_needs_paid_learner(self, mock_mailgun_client):
"""
Test that a learner attempting to email another learner will only succeed if the sender
has paid for a course run in a program that the recipient is enrolled in
"""
mock_mailgun_client.send_individual_email.return_value = Mock(
spec=Response, status_code=status.HTTP_200_OK, json=mocked_json())
with mute_signals(post_save):
learner_profile = ProfileFactory.create(
user__email='*****@*****.**',
email_optin=True,
)
learner_user = learner_profile.user
ProgramEnrollmentFactory.create(user=learner_user,
program=self.program)
CachedEnrollment.objects.filter(user=learner_user).delete()
self.client.force_login(learner_user)
url = reverse(
self.url_name,
kwargs={'student_id': self.recipient_user.profile.student_id})
resp_post = self.client.post(url,
data=self.request_data,
format='json')
assert resp_post.status_code == status.HTTP_403_FORBIDDEN
CachedEnrollmentFactory.create(
user=learner_user,
course_run__course__program=self.program,
verified=True)
resp_post = self.client.post(url,
data=self.request_data,
format='json')
assert resp_post.status_code == status.HTTP_200_OK
def setUpTestData(cls):
super().setUpTestData()
cls.program_enrollment_unsent = ProgramEnrollmentFactory.create()
cls.program_enrollment_sent = ProgramEnrollmentFactory.create()
cls.automatic_email = AutomaticEmailFactory.create(enabled=True)
cls.percolate_query = cls.automatic_email.query
cls.other_query = PercolateQueryFactory.create(
source_type=PercolateQuery.DISCUSSION_CHANNEL_TYPE)
cls.percolate_queries = [cls.percolate_query, cls.other_query]
cls.automatic_email_disabled = AutomaticEmailFactory.create(
enabled=False)
cls.percolate_query_disabled = cls.automatic_email_disabled.query
SentAutomaticEmail.objects.create(
automatic_email=cls.automatic_email,
user=cls.program_enrollment_sent.user,
status=SentAutomaticEmail.SENT,
)
# User was sent email connected to a different AutomaticEmail
SentAutomaticEmail.objects.create(
user=cls.program_enrollment_unsent.user,
automatic_email=AutomaticEmailFactory.create(enabled=True),
status=SentAutomaticEmail.SENT,
)
with mute_signals(post_save):
cls.staff_user = UserFactory.create()
def test_add_moderators_to_channel(mocker, patched_users_api):
"""add_moderators_to_channel should add staff or instructors as moderators and subscribers"""
channel = ChannelFactory.create()
mods = []
for _ in range(3):
program = ChannelProgramFactory.create(channel=channel).program
with mute_signals(post_save):
mods += [
RoleFactory.create(
program=program,
user=ProfileFactory.create().user
).user for _ in range(5)
]
for __ in range(5):
# Add some users to the channel to show that being part of the channel is not enough to be added as a mod
ProgramEnrollmentFactory.create(program=program)
create_stub, _ = patched_users_api
create_stub.reset_mock()
add_subscriber_stub = mocker.patch('discussions.api.add_subscriber_to_channel', autospec=True)
add_moderator_stub = mocker.patch('discussions.api.add_moderator_to_channel', autospec=True)
api.add_moderators_to_channel(channel.name)
for mod in mods:
add_subscriber_stub.assert_any_call(channel.name, mod.discussion_user.username)
add_moderator_stub.assert_any_call(channel.name, mod.discussion_user.username)
create_stub.assert_any_call(mod.discussion_user)
assert add_subscriber_stub.call_count == len(mods)
assert add_moderator_stub.call_count == len(mods)
assert create_stub.call_count == len(mods)
def create_learners_in_program(self,
learners_count,
privacy=Profile.PUBLIC):
"""helper function to create a list of learners in the program"""
for _ in range(0, learners_count):
user = create_learner_with_image(privacy)
ProgramEnrollmentFactory.create(
user=user,
program=self.program,
)
def test_course_team_email_unpaid(self):
"""
Test that an attempt to send an email to the course team of an unpaid course will fail
"""
self.client.force_login(self.staff_user)
new_course = CourseFactory.create(contact_email='*****@*****.**')
ProgramEnrollmentFactory.create(user=self.staff_user, program=new_course.program)
url = reverse(self.url_name, kwargs={'course_id': new_course.id})
resp = self.client.post(url, data=self.request_data, format='json')
assert resp.status_code == status.HTTP_403_FORBIDDEN
def test_program_enrollment_clear_upon_profile_deletion(self):
"""
Test that all ProgramEnrollments are cleared from the index after the User's Profile has been deleted
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
ProgramEnrollmentFactory.create(user=profile.user)
ProgramEnrollmentFactory.create(user=profile.user)
assert es.search()['total'] == 2
profile.delete()
assert es.search()['total'] == 0
def test_course_team_email_unpaid(self):
"""
Test that an attempt to send an email to the course team of an unpaid course will fail
"""
self.client.force_login(self.staff_user)
new_course = CourseFactory.create(contact_email='*****@*****.**')
ProgramEnrollmentFactory.create(user=self.staff_user,
program=new_course.program)
url = reverse(self.url_name, kwargs={'course_id': new_course.id})
resp = self.client.post(url, data=self.request_data, format='json')
assert resp.status_code == status.HTTP_403_FORBIDDEN
def test_authorize_enrollment_for_exam_run(self, authorize_for_latest_passed_course_mock):
"""Test authorize_enrollment_for_exam_run()"""
program, _ = create_program()
course = program.course_set.first()
enrollment_1 = ProgramEnrollmentFactory.create(program=program)
enrollment_2 = ProgramEnrollmentFactory.create(program=program)
exam_run = ExamRunFactory.create(course=course)
authorize_enrollment_for_exam_run([enrollment_1.id, enrollment_2.id], exam_run.id)
assert authorize_for_latest_passed_course_mock.call_count == 2
authorize_for_latest_passed_course_mock.assert_any_call(enrollment_1.user, exam_run)
authorize_for_latest_passed_course_mock.assert_any_call(enrollment_2.user, exam_run)
def setUpTestData(cls):
cls.user = UserFactory.create(username='******',
email='*****@*****.**')
cls.course_runs = {
'fa':
CourseRunFactory.create(
course__program__financial_aid_availability=True),
'non_fa':
CourseRunFactory.create(
course__program__financial_aid_availability=False)
}
for course_run in cls.course_runs.values():
ProgramEnrollmentFactory.create(user=cls.user,
program=course_run.course.program)
def test_bulk_authorize_for_exam_run_multiple(self):
"""Test that we check all program enrollments"""
ProgramEnrollmentFactory.create(program=self.program)
exam_run = ExamRunFactory.create(course=self.course_run.course)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
).count() == 0
bulk_authorize_for_exam_run(exam_run)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
user=self.user
).count() == 1
def test_program_enrollment_add(self):
"""
Test that a newly created ProgramEnrollment is indexed properly
"""
assert es.search()['total'] == 0
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(), [program_enrollment])
def test_document_needs_update_missing(self):
"""
If a document doesn't exist on Elasticsearch, document_needs_update should return true
"""
with mute_signals(post_save):
enrollment = ProgramEnrollmentFactory.create()
assert document_needs_updating(enrollment) is True
def test_program_enrollment_add(self, index_type, mock_on_commit):
"""
Test that a newly created ProgramEnrollment is indexed properly
"""
assert es.search(index_type)['total'] == 0
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_role_delete(self, role, index_type, mock_on_commit):
"""
Test that `is_learner` status is restore once role is removed for a user.
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
sources = get_sources(es.search(index_type))
# user is learner
assert sources[0]['program']['is_learner'] is True
Role.objects.create(user=program_enrollment.user,
program=program_enrollment.program,
role=role)
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
# user is not learner
sources = get_sources(es.search(index_type))
assert sources[0]['program']['is_learner'] is False
# when staff role is deleted
Role.objects.filter(user=program_enrollment.user,
program=program_enrollment.program,
role=role).delete()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
sources = get_sources(es.search(index_type))
# user is learner
assert sources[0]['program']['is_learner'] is True
def test_update_during_recreate_index(self):
"""
If an indexing action happens during a recreate_index it should update all active indices
"""
conn = get_conn(verify=False)
recreate_index()
temp_aliases = {}
index_types = [PRIVATE_ENROLLMENT_INDEX_TYPE, PUBLIC_ENROLLMENT_INDEX_TYPE]
for index_type in index_types:
# create temporary index
temp_index = make_backing_index_name()
temp_alias = make_alias_name(index_type=index_type, is_reindexing=True)
clear_and_create_index(temp_index, index_type=index_type)
conn.indices.put_alias(index=temp_index, name=temp_alias)
temp_aliases[index_type] = temp_alias
with patch('search.signals.transaction.on_commit', side_effect=lambda callback: callback()):
program_enrollment = ProgramEnrollmentFactory.create()
for index_type in index_types:
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
# Temp alias should get updated
temp_alias = temp_aliases[index_type]
refresh_index(temp_alias)
temp_hits = conn.search(index=temp_alias)['hits']
assert_search(temp_hits, [program_enrollment], index_type=index_type)
def test_role_delete(self, role, index_type, mock_on_commit):
"""
Test that `is_learner` status is restore once role is removed for a user.
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
sources = get_sources(es.search(index_type))
# user is learner
assert sources[0]['program']['is_learner'] is True
Role.objects.create(
user=program_enrollment.user,
program=program_enrollment.program,
role=role
)
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
# user is not learner
sources = get_sources(es.search(index_type))
assert sources[0]['program']['is_learner'] is False
# when staff role is deleted
Role.objects.filter(
user=program_enrollment.user,
program=program_enrollment.program,
role=role
).delete()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
sources = get_sources(es.search(index_type))
# user is learner
assert sources[0]['program']['is_learner'] is True
def test_update_percolate_memberships(self, source_type, is_member,
query_matches, mock_on_commit):
"""
Tests that existing memberships are updated where appropriate
"""
with mute_signals(post_save):
query = PercolateQueryFactory.create(source_type=source_type)
profile = ProfileFactory.create(filled_out=True)
program_enrollment = ProgramEnrollmentFactory.create(
user=profile.user)
membership = PercolateQueryMembershipFactory.create(
user=profile.user,
query=query,
is_member=is_member,
needs_update=False)
with patch('search.api._search_percolate_queries',
return_value=[query.id]
if query_matches else []) as search_percolate_queries_mock:
update_percolate_memberships(profile.user, source_type)
search_percolate_queries_mock.assert_called_once_with(
program_enrollment)
membership.refresh_from_db()
assert membership.needs_update is (is_member is not query_matches)
def setUpTestData(cls):
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
cls.course = cls.course_run.course
cls.program_enrollment = ProgramEnrollmentFactory.create(
program=cls.program)
cls.user = cls.program_enrollment.user
with mute_signals(post_save):
cls.final_grades = sorted(
[
FinalGradeFactory.create(user=cls.user,
course_run=cls.course_run,
passed=False,
status=FinalGradeStatus.PENDING),
FinalGradeFactory.create(user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE),
FinalGradeFactory.create(user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE),
],
key=lambda final_grade: final_grade.course_run.end_date,
reverse=True)
def setUpTestData(cls):
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
cls.course = cls.course_run.course
cls.program_enrollment = ProgramEnrollmentFactory.create(program=cls.program)
cls.user = cls.program_enrollment.user
with mute_signals(post_save):
cls.final_grades = sorted([
FinalGradeFactory.create(
user=cls.user,
course_run=cls.course_run,
passed=False,
status=FinalGradeStatus.PENDING
),
FinalGradeFactory.create(
user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE
),
FinalGradeFactory.create(
user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE
),
], key=lambda final_grade: final_grade.course_run.end_date, reverse=True)
def test_update_percolate_memberships(self, source_type, is_member, query_matches, mock_on_commit):
"""
Tests that existing memberships are updated where appropriate
"""
with mute_signals(post_save):
query = PercolateQueryFactory.create(source_type=source_type)
profile = ProfileFactory.create(filled_out=True)
program_enrollment = ProgramEnrollmentFactory.create(user=profile.user)
membership = PercolateQueryMembershipFactory.create(
user=profile.user,
query=query,
is_member=is_member,
needs_update=False
)
with patch(
'search.api._search_percolate_queries',
return_value=[query.id] if query_matches else []
) as search_percolate_queries_mock:
update_percolate_memberships(profile.user, source_type)
search_percolate_queries_mock.assert_called_once_with(program_enrollment)
membership.refresh_from_db()
assert membership.needs_update is (is_member is not query_matches)
def test_authorize_exam_runs(self, authorized,
authorize_for_latest_passed_course_mock):
"""Test authorize_exam_runs()"""
program, _ = create_program()
course = program.course_set.first()
enrollment = ProgramEnrollmentFactory.create(program=program)
current_run = ExamRunFactory.create(course=course,
authorized=authorized)
past_run = ExamRunFactory.create(course=course,
scheduling_future=True,
authorized=authorized)
future_run = ExamRunFactory.create(course=course,
scheduling_past=True,
authorized=authorized)
authorize_exam_runs()
if authorized:
assert authorize_for_latest_passed_course_mock.call_count == 0
else:
assert authorize_for_latest_passed_course_mock.call_count == 2
authorize_for_latest_passed_course_mock.assert_any_call(
enrollment.user, current_run)
authorize_for_latest_passed_course_mock.assert_any_call(
enrollment.user, future_run)
for exam_run in (current_run, future_run):
exam_run.refresh_from_db()
assert exam_run.authorized is True
past_run.refresh_from_db()
assert past_run.authorized is False
def test_populate_query_memberships(self, source_type, is_member,
query_matches, mock_on_commit):
"""
Tests that existing memberships are updated where appropriate
"""
with mute_signals(post_save):
query = PercolateQueryFactory.create(source_type=source_type)
profiles = [
ProfileFactory.create(filled_out=True) for _ in range(3)
]
program_enrollments = [
ProgramEnrollmentFactory.create(user=profile.user)
for profile in profiles
]
with patch('search.api._search_percolate_queries',
return_value=[query.id]
if query_matches else []) as search_percolate_queries_mock:
populate_query_memberships(query.id)
assert search_percolate_queries_mock.call_count == len(
program_enrollments)
for program_enrollment in program_enrollments:
search_percolate_queries_mock.assert_any_call(program_enrollment)
for profile in profiles:
membership = PercolateQueryMembership.objects.get(
user=profile.user, query=query)
assert membership.is_member is query_matches
assert membership.needs_update is True
def test_update_during_recreate_index(self):
"""
If an indexing action happens during a recreate_index it should update all active indices
"""
conn = get_conn(verify=False)
recreate_index()
temp_aliases = {}
index_types = [
PRIVATE_ENROLLMENT_INDEX_TYPE, PUBLIC_ENROLLMENT_INDEX_TYPE
]
for index_type in index_types:
# create temporary index
temp_index = make_backing_index_name()
temp_alias = make_alias_name(index_type=index_type,
is_reindexing=True)
clear_and_create_index(temp_index, index_type=index_type)
conn.indices.put_alias(index=temp_index, name=temp_alias)
temp_aliases[index_type] = temp_alias
with patch('search.signals.transaction.on_commit',
side_effect=lambda callback: callback()):
program_enrollment = ProgramEnrollmentFactory.create()
for index_type in index_types:
assert_search(es.search(index_type), [program_enrollment],
index_type=index_type)
# Temp alias should get updated
temp_alias = temp_aliases[index_type]
refresh_index(temp_alias)
temp_hits = conn.search(index=temp_alias)['hits']
assert_search(temp_hits, [program_enrollment],
index_type=index_type)
def test_document_needs_update_missing(self):
"""
If a document doesn't exist on Elasticsearch, document_needs_update should return true
"""
with mute_signals(post_save):
enrollment = ProgramEnrollmentFactory.create()
assert document_needs_updating(enrollment) is True
def test_program_enrollment_delete(self, index_type, mock_on_commit):
"""
Test that ProgramEnrollment is removed from index after the user is removed
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
program_enrollment.user.delete()
assert es.search(index_type)['total'] == 0
def test_program_enrollment_add(self, index_type, mock_on_commit):
"""
Test that a newly created ProgramEnrollment is indexed properly
"""
assert es.search(index_type)['total'] == 0
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(index_type), [program_enrollment],
index_type=index_type)
def test_employment_add(self):
"""
Test that Employment is indexed after being added
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search()['total'] == 1
EmploymentFactory.create(profile=program_enrollment.user.profile)
assert_search(es.search(), [program_enrollment])
def setUpTestData(cls):
super().setUpTestData()
with mute_signals(post_save):
staff_profile = ProfileFactory.create()
cls.staff_user = staff_profile.user
cls.course = CourseFactory.create(
contact_email='*****@*****.**',
program__financial_aid_availability=False
)
course_run = CourseRunFactory.create(course=cls.course)
ProgramEnrollmentFactory.create(user=cls.staff_user, program=cls.course.program)
CachedEnrollmentFactory.create(user=cls.staff_user, course_run=course_run)
cls.url_name = 'course_team_mail_api'
cls.request_data = {
'email_subject': 'email subject',
'email_body': 'email body'
}
def test_program_enrollment_delete(self):
"""
Test that ProgramEnrollment is removed from index after the user is removed
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search()['total'] == 1
program_enrollment.user.delete()
assert es.search()['total'] == 0
def test_remove_program_enrolled_user(self):
"""
Test that remove_program_enrolled_user removes the user from the index for that program
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(), [program_enrollment])
remove_program_enrolled_user(program_enrollment)
assert_search(es.search(), [])
def test_program_enrollment_delete(self, index_type, mock_on_commit):
"""
Test that ProgramEnrollment is removed from index after the user is removed
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
program_enrollment.user.delete()
assert es.search(index_type)['total'] == 0
def test_program_record_with_random_user(client):
"""Test that a request for program record with random (non-owner) user results in 404"""
user = UserFactory.create()
client.force_login(user)
enrollment = ProgramEnrollmentFactory.create()
resp = client.get(
reverse("grade_records", kwargs=dict(enrollment_id=enrollment.id)))
assert resp.status_code == status.HTTP_404_NOT_FOUND
def test_index_users(self):
"""
When we run the index_users task we should index user's program enrollments and send them automatic emails
"""
enrollment1 = ProgramEnrollmentFactory.create()
enrollment2 = ProgramEnrollmentFactory.create(user=enrollment1.user)
index_users([enrollment1.user.id])
assert self.index_program_enrolled_users_mock.call_count == 1
assert sorted(self.index_program_enrolled_users_mock.call_args[0][0],
key=lambda _enrollment: _enrollment.id) == sorted(
[enrollment1, enrollment2],
key=lambda _enrollment: _enrollment.id)
for enrollment in [enrollment1, enrollment2]:
self.send_automatic_emails_mock.assert_any_call(enrollment)
self.update_percolate_memberships_mock.assert_any_call(
enrollment.user, PercolateQuery.DISCUSSION_CHANNEL_TYPE)
self.refresh_index_mock.assert_called_with()
def test_employment_add(self, index_type, mock_on_commit):
"""
Test that Employment is indexed after being added
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
EmploymentFactory.create(profile=program_enrollment.user.profile, end_date=None)
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_remove_program_enrolled_user(self, index_type, mock_on_commit):
"""
Test that remove_program_enrolled_user removes the user from the index for that program
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
remove_program_enrolled_user(program_enrollment.id)
assert_search(es.search(index_type), [], index_type=index_type)
def test_education_add(self, index_type, mock_on_commit):
"""
Test that Education is indexed after being added
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
EducationFactory.create(profile=program_enrollment.user.profile)
assert_search(es.search(index_type), [program_enrollment],
index_type=index_type)
def test_not_percolated(self, mock_on_commit):
"""If there are no percolated queries we should return an empty queryset"""
with mute_signals(post_save):
profile = ProfileFactory.create(filled_out=True)
program_enrollment = ProgramEnrollmentFactory.create(user=profile.user)
assert list(
search_percolate_queries(
program_enrollment.id,
PercolateQuery.AUTOMATIC_EMAIL_TYPE)) == []
def test_populate_query_inactive_memberships(self, is_active, has_profile, mock_on_commit):
"""
Tests that memberships are handled correctly for users who are inactive or have no profiles
"""
with mute_signals(post_save):
query = PercolateQueryFactory.create(source_type=PercolateQuery.DISCUSSION_CHANNEL_TYPE)
user = UserFactory.create(is_active=is_active)
if has_profile:
ProfileFactory.create(user=user, filled_out=True)
ProgramEnrollmentFactory.create(user=user)
with patch('search.api.get_conn') as es_mock:
populate_query_memberships(query.id)
assert es_mock.return_value.percolate.call_count == (1 if has_profile and is_active else 0)
assert PercolateQueryMembership.objects.filter(user=user, query=query).count() == (
1 if is_active else 0
)
def test_employment_delete(self, index_type, mock_on_commit):
"""
Test that Employment is removed from index after being deleted
"""
program_enrollment = ProgramEnrollmentFactory.create()
employment = EmploymentFactory.create(profile=program_enrollment.user.profile, end_date=None)
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
employment.delete()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_education_delete(self, index_type, mock_on_commit):
"""
Test that Education is removed from index after being deleted
"""
program_enrollment = ProgramEnrollmentFactory.create()
education = EducationFactory.create(profile=program_enrollment.user.profile)
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
education.delete()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_staff_and_instructor_in_other_program_no_results(self, role, is_enrolled):
"""A user with staff or instructor role in another program gets no results"""
user = UserFactory.create()
Role.objects.create(
user=user,
program=self.program2,
role=role,
)
if is_enrolled:
ProgramEnrollmentFactory.create(user=user, program=self.program1)
params = {
"post_filter": {
"term": {"program.id": self.program1.id}
}
}
self.client.force_login(user)
resp = self.assert_status_code(json=params)
assert len(resp.data['hits']['hits']) == 0
def test_remove_program_enrolled_user(self, index_type, mock_on_commit):
"""
Test that remove_program_enrolled_user removes the user from the index for that program
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(index_type), [program_enrollment],
index_type=index_type)
remove_program_enrolled_user(program_enrollment.id)
assert_search(es.search(index_type), [], index_type=index_type)
def test_education_update(self, index_type, mock_on_commit):
"""
Test that Education is reindexed after being updated
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
education = EducationFactory.create(profile=program_enrollment.user.profile)
education.school_city = 'city'
education.save()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_past_employment_add(self, index_type, mock_on_commit):
"""
Test that past work history is not indexed
"""
program_enrollment = ProgramEnrollmentFactory.create()
EmploymentFactory.create(profile=program_enrollment.user.profile, end_date=None)
EmploymentFactory.create(profile=program_enrollment.user.profile)
search_result = es.search(index_type)['hits'][0]['_source']['profile']['work_history']
assert len(search_result) == 1
self.assertFalse(search_result[0]['end_date'])
def test_profile_update(self, index_type, mock_on_commit):
"""
Test that ProgramEnrollment is reindexed after the User's Profile has been updated
"""
program_enrollment = ProgramEnrollmentFactory.create()
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
profile = program_enrollment.user.profile
profile.first_name = 'updated'
profile.save()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_document_needs_update(self, mocked_on_commit):
"""
If a document on ES is out of date with the database, document_needs_update should return true
"""
enrollment = ProgramEnrollmentFactory.create()
assert document_needs_updating(enrollment) is False
with mute_signals(post_save):
enrollment.user.profile.first_name = "Changed"
enrollment.user.profile.save()
assert document_needs_updating(enrollment) is True
def test_add_edx_record(self, index_type, mock_on_commit):
"""
Test that cached edX records are indexed after being added
"""
program_enrollment = ProgramEnrollmentFactory.create()
for edx_cached_model_factory in [CachedCertificateFactory, CachedEnrollmentFactory, CachedCurrentGradeFactory]:
assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT
course = CourseFactory.create(program=program_enrollment.program)
course_run = CourseRunFactory.create(course=course)
edx_cached_model_factory.create(user=program_enrollment.user, course_run=course_run)
index_program_enrolled_users([program_enrollment])
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_percolate_failure_user_unenroll_program(self, mock_on_commit):
"""
If search_percolate fails we should raise an Exception with some useful information for Sentry
Case when there is not program enrollment.
"""
with mute_signals(post_save):
profile = ProfileFactory.create(filled_out=True)
program_enrollment = ProgramEnrollmentFactory.create(user=profile.user)
program_enrollment_id = program_enrollment.id
program_enrollment.delete()
with self.assertRaises(ProgramEnrollment.DoesNotExist):
search_percolate_queries(program_enrollment_id, "doesnt_matter")
def test_update_index(self, index_type):
"""
Test that recreate_index will clear old data and index all profiles
"""
with patch('search.signals.transaction.on_commit', side_effect=lambda callback: callback()):
program_enrollment = ProgramEnrollmentFactory.create()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
remove_program_enrolled_user(program_enrollment.id)
assert_search(es.search(index_type), [], index_type=index_type)
# recreate_index should index the program-enrolled user
recreate_index()
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_delete_edx_record(self, index_type, mock_on_commit):
"""
Test that a cached edX record is removed from index after being deleted
"""
program_enrollment = ProgramEnrollmentFactory.create()
for edx_cached_model_factory in [CachedCertificateFactory, CachedEnrollmentFactory, CachedCurrentGradeFactory]:
course = CourseFactory.create(program=program_enrollment.program)
course_run = CourseRunFactory.create(course=course)
edx_record = edx_cached_model_factory.create(user=program_enrollment.user, course_run=course_run)
index_program_enrolled_users([program_enrollment])
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
edx_record.delete()
index_program_enrolled_users([program_enrollment])
assert_search(es.search(index_type), [program_enrollment], index_type=index_type)