def test_generatereviews(self):
PROFILES_TO_CREATE = 20
ProfileFactory.create_batch(PROFILES_TO_CREATE)
call_command('generatereviews', reviews_count=self.REVIEWS_TO_CREATE)
review_count = Review.objects.count()
self.assertEqual(review_count, self.REVIEWS_TO_CREATE)
def test_patch_own_profile(self):
"""
A user PATCHes their own profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1,
filled_out=False,
agreed_to_terms_of_service=False)
self.client.force_login(self.user1)
with mute_signals(post_save):
new_profile = ProfileFactory.create(filled_out=False)
new_profile.user.social_auth.create(provider=EdxOrgOAuth2.name,
uid="{}_edx".format(
new_profile.user.username))
patch_data = ProfileSerializer().to_representation(new_profile)
resp = self.client.patch(self.url1,
content_type="application/json",
data=json.dumps(patch_data))
assert resp.status_code == 200
old_profile = Profile.objects.get(user__username=self.user1.username)
for key, value in patch_data.items():
field = ProfileSerializer().fields[key]
if isinstance(field, (ListSerializer, SerializerMethodField,
ReadOnlyField)) or field.read_only is True:
# these fields are readonly
continue
elif isinstance(field, DateField):
assert getattr(old_profile, key) == parse(value).date()
else:
assert getattr(old_profile, key) == value
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_staff_sees_entire_profile(self):
"""
Staff should be able to see the entire profile despite the account privacy
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user2,
account_privacy=Profile.PRIVATE)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=False)
program = ProgramFactory.create()
ProgramEnrollment.objects.create(
program=program,
user=profile.user,
)
Role.objects.create(
program=program,
role=Staff.ROLE_ID,
user=self.user1,
)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
profile_data = ProfileSerializer(profile).data
assert resp.json() == format_image_expectation(profile_data)
def test_redirects_to_itself_when_submitted_second_time(self):
self.user.passport_photo = ProfileFactory.create_passport_photo()
self.user.bar_license_photo = ProfileFactory.create_bar_license_photo()
self.user.save()
response = self.client.post(self.VIEW_URL, data=self.data_payload)
self.assertRedirects(response, self.VIEW_URL)
def test_patch_own_profile(self):
"""
A user PATCHes their own profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False)
self.client.force_login(self.user1)
with mute_signals(post_save):
new_profile = ProfileFactory.create(filled_out=False)
new_profile.user.social_auth.create(
provider=EdxOrgOAuth2.name,
uid="{}_edx".format(new_profile.user.username)
)
patch_data = ProfileSerializer(new_profile).data
del patch_data['image']
resp = self.client.patch(self.url1, content_type="application/json", data=json.dumps(patch_data))
assert resp.status_code == 200
old_profile = Profile.objects.get(user__username=self.user1.username)
for key, value in patch_data.items():
field = ProfileSerializer().fields[key]
if isinstance(field, (ListSerializer, SerializerMethodField, ReadOnlyField)) or field.read_only is True:
# these fields are readonly
continue
elif isinstance(field, DateField):
assert getattr(old_profile, key) == parse(value).date()
else:
assert getattr(old_profile, key) == value
def test_is_attorney_proof_submitted(self):
profile = ProfileFactory(no_attorney_proof=True)
self.assertFalse(profile.is_attorney_proof_submitted())
profile.passport_photo = ProfileFactory.create_passport_photo()
profile.bar_license_photo = ProfileFactory.create_bar_license_photo()
profile.save()
self.assertTrue(profile.is_attorney_proof_submitted())
def setUp(self):
self.data_payload = {
"passport_photo": ProfileFactory.create_passport_photo(),
"bar_license_photo": ProfileFactory.create_bar_license_photo(),
"attorney_confirm": "on",
}
self.user = ProfileFactory(no_attorney_proof=True)
self.client.force_login(self.user)
def test_forbidden_methods(self):
"""
POST is not implemented.
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1)
self.client.force_login(self.user1)
assert self.client.post(self.url1).status_code == HTTP_405_METHOD_NOT_ALLOWED
def test_anonym_user_get_private_profile(self):
"""
An anonymous user gets user's private profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2, account_privacy=Profile.PRIVATE)
self.client.logout()
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_generatetransactions(self):
PROFILES_TO_CREATE = 10
ProfileFactory.create_batch(size=PROFILES_TO_CREATE)
call_command('generatetransactions',
transactions_count=self.TRANSACTIONS_TO_CREATE)
transaction_count = Transaction.objects.count()
self.assertEqual(transaction_count, self.TRANSACTIONS_TO_CREATE)
def handle(self, *args, **options):
try:
ProfileFactory.create_batch(options['profile_count'])
except IntegrityError as ie:
raise CommandError(
'Unable to generate dummy profiles, truncate your database and try again.',
ie)
except Exception as ex:
raise CommandError('Unable to generate dummy profiles.', ex)
def test_forbidden_methods(self):
"""
POST is not implemented.
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1)
self.client.force_login(self.user1)
assert self.client.post(
self.url1).status_code == HTTP_405_METHOD_NOT_ALLOWED
def test_weird_privacy_get_private_profile(self):
"""
If a user profile has a weird profile setting, it defaults to private
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2, account_privacy='weird_setting')
ProfileFactory.create(user=self.user1, verified_micromaster_user=True)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_vermm_user_get_private_profile(self):
"""
A verified mm user gets user's private profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2, account_privacy=Profile.PRIVATE)
ProfileFactory.create(user=self.user1, verified_micromaster_user=True)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_mm_user_get_public_to_mm_profile(self):
"""
An unverified mm user gets user's public_to_mm profile.
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2, account_privacy=Profile.PUBLIC_TO_MM)
ProfileFactory.create(user=self.user1, verified_micromaster_user=False)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_anonym_user_get_private_profile(self):
"""
An anonymous user gets user's private profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2,
account_privacy=Profile.PRIVATE)
self.client.logout()
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def setUpTestData(cls):
cls.created_by = ProfileFactory()
cls.sent_to = ProfileFactory()
cls.data_payload = {
'date': timezone.now(),
'amount': 1234,
'currency': 'USD',
'is_requester_principal': True
}
def test_vermm_user_get_public_profile(self):
"""
A verified mm user gets another user's public profile.
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user2, account_privacy=Profile.PUBLIC)
ProfileFactory.create(user=self.user1, verified_micromaster_user=True)
profile_data = ProfileLimitedSerializer(profile).data
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.json() == format_image_expectation(profile_data)
def test_check_object_permissions(self):
"""
Make sure check_object_permissions is called at some point so the permissions work correctly
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1, account_privacy=Profile.PUBLIC)
self.client.force_login(self.user1)
with patch.object(ProfileViewSet, 'check_object_permissions', autospec=True) as check_object_permissions:
self.client.get(self.url1)
assert check_object_permissions.called
def test_generate_profiles_working(self):
GENERATED_MODELS_COUNT = 25
existing_profiles_count = Profile.objects.count()
ProfileFactory.create_batch(GENERATED_MODELS_COUNT)
new_profiles_count = Profile.objects.count()
self.assertEqual(new_profiles_count,
existing_profiles_count + GENERATED_MODELS_COUNT)
def test_weird_privacy_get_private_profile(self):
"""
If a user profile has a weird profile setting, it defaults to private
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2,
account_privacy='weird_setting')
ProfileFactory.create(user=self.user1,
verified_micromaster_user=True)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_mm_user_get_public_to_mm_profile(self):
"""
An unverified mm user gets user's public_to_mm profile.
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2,
account_privacy=Profile.PUBLIC_TO_MM)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=False)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_users_can_view_public_profile(self):
"""
Users are allowed to view public profile.
"""
perm = CanSeeIfNotPrivate()
with mute_signals(post_save):
ProfileFactory.create(user=self.profile_user,
account_privacy=Profile.PUBLIC)
request = Mock(user=self.other_user)
view = Mock(kwargs={'user': self.profile_user_id})
assert perm.has_permission(request, view) is True
def test_vermm_user_get_private_profile(self):
"""
A verified mm user gets user's private profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user2,
account_privacy=Profile.PRIVATE)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=True)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.status_code == HTTP_404_NOT_FOUND
def test_vermm_user_get_public_profile(self):
"""
A verified mm user gets another user's public profile.
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user2,
account_privacy=Profile.PUBLIC)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=True)
profile_data = ProfileLimitedSerializer(profile).data
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.json() == format_image_expectation(profile_data)
def test_vermm_user_get_public_to_mm_profile(self):
"""
A verified mm user gets user's public_to_mm profile.
"""
with mute_signals(post_save):
profile = ProfileFactory.create(
user=self.user2, account_privacy=Profile.PUBLIC_TO_MM)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=True)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
assert resp.json() == ProfileLimitedSerializer().to_representation(
profile)
def test_cant_view_public_if_anonymous_user(self):
"""
Anonymous are not supposed to view private profiles.
"""
perm = CanSeeIfNotPrivate()
with mute_signals(post_save):
ProfileFactory.create(user=self.profile_user,
account_privacy=Profile.PUBLIC)
request = Mock(user=Mock(is_anonymous=Mock(return_value=True)))
view = Mock(kwargs={'user': self.profile_user_id})
assert perm.has_permission(request, view) is True
def test_cant_view_if_non_verified_mm_user(self):
"""
Non verified micromaster users are not supposed to view public_to_mm profiles.
"""
perm = CanSeeIfNotPrivate()
with mute_signals(post_save):
ProfileFactory.create(user=self.profile_user,
account_privacy=Profile.PUBLIC_TO_MM)
request = Mock(user=self.other_user)
view = Mock(kwargs={'user': self.profile_user_id})
with self.assertRaises(Http404):
perm.has_permission(request, view)
def test_cant_view_if_privacy_weird(self):
"""
Users can not open profiles with ambiguous account_privacy settings.
"""
perm = CanSeeIfNotPrivate()
with mute_signals(post_save):
ProfileFactory.create(user=self.profile_user,
account_privacy='weird_setting')
request = Mock(user=self.other_user)
view = Mock(kwargs={'user': self.profile_user_id})
with self.assertRaises(Http404):
perm.has_permission(request, view)
def test_check_object_permissions(self):
"""
Make sure check_object_permissions is called at some point so the permissions work correctly
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1,
account_privacy=Profile.PUBLIC)
self.client.force_login(self.user1)
with patch.object(ProfileViewSet,
'check_object_permissions',
autospec=True) as check_object_permissions:
self.client.get(self.url1)
assert check_object_permissions.called
def test_cant_view_if_privacy_is_private(self):
"""
Users are not supposed to view private profiles.
"""
perm = CanSeeIfNotPrivate()
with mute_signals(post_save):
ProfileFactory.create(user=self.profile_user,
account_privacy=Profile.PRIVATE)
request = Mock(user=self.other_user)
view = Mock(kwargs={'user': self.profile_user_id})
with self.assertRaises(Http404):
perm.has_permission(request, view)
def test_verified_enroll_factory_fa_create(self):
"""
Tests that CachedEnrollmentFactory creates additional data for a FA-enabled course run
"""
assert Line.objects.count() == 0
with mute_signals(post_save):
user = UserFactory.create()
ProfileFactory.create(user=user)
fa_program = FullProgramFactory.create(financial_aid_availability=True)
CachedEnrollmentFactory.create(user=user,
course_run__course__program=fa_program,
verified=True)
lines = Line.objects.all()
assert len(lines) == 1
assert lines[0].order.status == Order.FULFILLED
def test_index_program_enrolled_users(self, mock_on_commit):
"""
Test that index_program_enrolled_users indexes an iterable of program-enrolled users
"""
num_enrollments = 10
chunk_size = 4
with mute_signals(post_save):
program_enrollments = [
ProgramEnrollmentFactory.create() for _ in range(num_enrollments)
]
for enrollment in program_enrollments:
ProfileFactory.create(user=enrollment.user)
private = [serialize_program_enrolled_user(enrollment) for enrollment in program_enrollments]
private_dicts = {serialized['id']: serialized for serialized in private}
public = [serialize_public_enrolled_user(serialized) for serialized in private]
public_dicts = {serialized['id']: serialized for serialized in public}
with patch(
'search.indexing_api._index_chunk', autospec=True, return_value=0
) as index_chunk, patch(
'search.indexing_api.serialize_program_enrolled_user', autospec=True,
side_effect=lambda x: private_dicts[x.id]
) as serialize_mock, patch(
'search.indexing_api.serialize_public_enrolled_user', autospec=True,
side_effect=lambda x: public_dicts[x['id']]
) as serialize_public_mock:
index_program_enrolled_users(program_enrollments, chunk_size=chunk_size)
assert index_chunk.call_count == 6 # 10 enrollments divided in chunks of 4, times the number of types (2)
public_index = make_alias_name(PUBLIC_ENROLLMENT_INDEX_TYPE, is_reindexing=False)
private_index = make_alias_name(PRIVATE_ENROLLMENT_INDEX_TYPE, is_reindexing=False)
for offset in range(0, num_enrollments, chunk_size):
# each enrollment should get yielded twice to account for each doctype
index_chunk.assert_any_call(
public[offset:offset+4], # ordered dicts FTW
index=public_index
)
index_chunk.assert_any_call(
private[offset:offset+4],
index=private_index
)
assert serialize_mock.call_count == len(program_enrollments)
assert serialize_public_mock.call_count == len(program_enrollments)
for enrollment in program_enrollments:
serialize_mock.assert_any_call(enrollment)
serialize_public_mock.assert_any_call(private_dicts[enrollment.id])
def setUpTestData(cls):
with mute_signals(post_save):
profile = ProfileFactory.create()
cls.user = profile.user
cls.program = ProgramFactory.create()
cls.program_enrollment = ProgramEnrollment.objects.create(
user=cls.user, program=cls.program)
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 test_update_discussion_user_no_update(mock_staff_client):
"""Verify update_discussion_user makes the correct API calls"""
with mute_signals(post_save):
profile = ProfileFactory.create()
discussion_user = DiscussionUser.objects.create(user=profile.user, username='******', last_sync=profile.updated_on)
api.update_discussion_user(discussion_user)
assert mock_staff_client.users.update.call_count == 0
def test_post_redirects(self):
"""Test that POST redirects to same URL"""
with mute_signals(post_save):
profile = ProfileFactory.create(agreed_to_terms_of_service=True, filled_out=True)
self.client.force_login(profile.user)
resp = self.client.post("/dashboard/", follow=True)
assert resp.redirect_chain == [('http://testserver/dashboard/', 302)]
def test_save_and_log(self):
"""
Tests that FinancialAid.save_and_log() creates an audit record with the correct information.
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
acting_user = profile.user
financial_aid = FinancialAidFactory.create()
original_before_json = serialize_model_object(financial_aid)
# Make sure audit object is created
assert FinancialAidAudit.objects.count() == 0
financial_aid.status = FinancialAidStatus.AUTO_APPROVED
financial_aid.save_and_log(acting_user)
assert FinancialAidAudit.objects.count() == 1
# Make sure the before and after data are correct
financial_aid.refresh_from_db()
original_after_json = serialize_model_object(financial_aid)
financial_aid_audit = FinancialAidAudit.objects.first()
before_json = financial_aid_audit.data_before
after_json = financial_aid_audit.data_after
for field, value in before_json.items():
# Data before
if isinstance(value, float):
# JSON serialization of FloatField is precise, so we need to do almost equal
self.assertAlmostEqual(value, original_before_json[field])
else:
assert value == original_before_json[field]
for field, value in after_json.items():
# Data after
if isinstance(value, float):
# JSON serialization of FloatField is precise, so we need to do almost equal
self.assertAlmostEqual(value, original_after_json[field])
else:
assert value == original_after_json[field]
def test_sync_user_profile_save_enabled(mocker, patched_users_api):
"""Test that sync_user_profile calls the task if enabled on save"""
mock_task = mocker.patch('discussions.tasks.sync_discussion_user')
with mute_signals(post_save):
profile = ProfileFactory.create()
profile.save()
mock_task.delay.assert_called_once_with(profile.user_id)
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_register_status_correct(self):
profile = ProfileFactory(empty_profile=True)
self.assertEqual(profile.register_status,
Profile.REGISTER_STATUS_EMPTY_PROFILE)
profile = ProfileFactory(no_attorney_proof=True)
self.assertEqual(profile.register_status,
Profile.REGISTER_STATUS_NO_ATTORNEY_PROOF)
profile = ProfileFactory(email_not_confirmed=True)
self.assertEqual(profile.register_status,
Profile.REGISTER_STATUS_EMAIL_NOT_CONFIRMED)
profile = ProfileFactory()
self.assertEqual(profile.register_status,
Profile.REGISTER_STATUS_COMPLETE)
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):
"""
Create a profile
"""
super().setUpTestData()
with mute_signals(post_save):
cls.profile = ProfileFactory.create()
def test_display_name_no_last_name(self):
"""Test the profile display name with a blank last name"""
with mute_signals(post_save):
profile = ProfileFactory(first_name='First',
last_name=None,
preferred_name=None)
assert profile.display_name == 'First'
def test_index_context_logged_in_staff(self, role):
"""
Assert context values when logged in as staff for a program
"""
program = ProgramFactory.create(live=True)
with mute_signals(post_save):
profile = ProfileFactory.create()
Role.objects.create(
role=role,
program=program,
user=profile.user,
)
self.client.force_login(profile.user)
ga_tracking_id = FuzzyText().fuzz()
with self.settings(
GA_TRACKING_ID=ga_tracking_id,
):
response = self.client.get('/')
assert response.context['authenticated'] is True
assert response.context['username'] is None
assert response.context['title'] == HomePage.objects.first().title
assert response.context['is_public'] is True
assert response.context['has_zendesk_widget'] is True
assert response.context['is_staff'] is True
assert response.context['programs'] == [
(program, None),
]
self.assertContains(response, 'Share this page')
js_settings = json.loads(response.context['js_settings_json'])
assert js_settings['gaTrackingID'] == ga_tracking_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_view_with_search(self, staff_client, program_data):
"""
Tests that ReviewFinancialAidView returns the expected results with search
"""
fin_aid_status = FinancialAidStatus.AUTO_APPROVED
profiles = ProfileFactory.create_batch(
4,
first_name=factory.Iterator(['match_name', 'x', 'y', 'z']),
last_name=factory.Iterator(['x', 'y', 'z', 'match_name']),
)
FinancialAidFactory.create_batch(
4,
tier_program=program_data.tier_programs["0k"],
status=fin_aid_status,
user=factory.Iterator([p.user for p in profiles])
)
name_query = 'match_name'
url = self.review_url(program_data.program.id, status=fin_aid_status, search_param=name_query)
resp = staff_client.get(url)
assert resp.status_code == status.HTTP_200_OK
financial_aid_objects = resp.context_data["financial_aid_objects"]
# Two users should match the search term - one for first_name, one for last_name
assert len(financial_aid_objects) == 2
assert all(
fin_aid.user.profile.first_name == name_query or fin_aid.user.profile.last_name == name_query
for fin_aid in financial_aid_objects
)
def create_enrolled_profile(program, role=None, **profile_kwargs):
"""
Helper function to create a profile and some related models
Args:
program (courses.models.Program):
A program
role (str or None):
A role, or no role if None
Returns:
profiles.models.Profile: A new profile
"""
with mute_signals(post_save):
profile = ProfileFactory.create(**profile_kwargs)
ProgramEnrollment.objects.create(
user=profile.user,
program=program
)
if role is not None:
Role.objects.create(
user=profile.user,
program=program,
role=role,
)
return profile
def setUpTestData(cls):
"""
Create a profile
"""
super().setUpTestData()
with mute_signals(post_save):
cls.profile = ProfileFactory.create()
def test_upload_image_creates_thumbnail(self, image_already_exists, thumb_already_exists):
"""
An image upload should cause the thumbnail to be updated
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False)
if image_already_exists is False:
profile.image = None
if thumb_already_exists is False:
profile.image_small = None
profile.image_medium = None
profile.save()
self.client.force_login(self.user1)
patch_data = ProfileSerializer(profile).data
del patch_data['image']
del patch_data['image_small']
del patch_data['image_medium']
# create a dummy image file in memory for upload
with make_temp_image_file() as image_file:
# format patch using multipart upload
resp = self.client.patch(self.url1, data={
'image': image_file
}, format='multipart')
assert resp.status_code == 200, resp.content.decode('utf-8')
profile.refresh_from_db()
assert profile.image.height == 500
assert profile.image.width == 500
assert profile.image_small.height == 64
assert profile.image_small.width == 64
assert profile.image_medium.height == 128
assert profile.image_medium.width == 128
def test_no_thumbnail_change_if_image_upload(self, image_already_exists, thumb_already_exists):
"""
A patch without an image upload should not touch the image or the thumbnail
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False)
if image_already_exists is False:
profile.image = None
if thumb_already_exists is False:
profile.image_small = None
profile.image_medium = None
profile.save()
self.client.force_login(self.user1)
patch_data = ProfileSerializer(profile).data
del patch_data['image']
del patch_data['image_small']
del patch_data['image_medium']
resp = self.client.patch(self.url1, content_type="application/json", data=json.dumps(patch_data))
assert resp.status_code == 200
profile.refresh_from_db()
assert bool(profile.image) == image_already_exists
assert bool(profile.image_small) == thumb_already_exists
assert bool(profile.image_medium) == thumb_already_exists
def test_readonly_resized_images(self, image_key):
"""
Users should not be able to modify image_small or image_medium directly
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user1)
self.client.force_login(self.user1)
# create a dummy image file in memory for upload
with make_temp_image_file() as image_file:
# save old thumbnail
resized_image_file = getattr(profile, image_key).file
backup_thumb_bytes = resized_image_file.read()
resized_image_file.seek(0)
# format patch using multipart upload
resp = self.client.patch(self.url1, data={
image_key: image_file
}, format='multipart')
assert resp.status_code == 200, resp.content.decode('utf-8')
profile.refresh_from_db()
# resized image should not have changed
thumb_bytes = getattr(profile, image_key).file.read()
assert thumb_bytes == backup_thumb_bytes
def test_unset_address(self):
"""Test splitting an unset address"""
with mute_signals(post_save):
profile = ProfileFactory(address=None)
assert profile.address1 is None
assert profile.address2 is None
assert profile.address3 is None
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_index_context_logged_in_no_social_auth(self):
"""
Assert context values when logged in without a social_auth account
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
self.client.force_login(profile.user)
ga_tracking_id = FuzzyText().fuzz()
with self.settings(
GA_TRACKING_ID=ga_tracking_id,
), patch('ui.templatetags.render_bundle._get_bundle') as get_bundle:
response = self.client.get('/')
bundles = [bundle[0][1] for bundle in get_bundle.call_args_list]
assert set(bundles) == {
'common',
'public',
'sentry_client',
'style',
'style_public',
'zendesk_widget',
}
assert response.context['authenticated'] is True
assert response.context['username'] is None
assert response.context['title'] == HomePage.objects.first().title
assert response.context['is_public'] is True
assert response.context['has_zendesk_widget'] is True
assert response.context['is_staff'] is False
assert response.context['programs'] == []
self.assertContains(response, 'Share this page')
js_settings = json.loads(response.context['js_settings_json'])
assert js_settings['gaTrackingID'] == ga_tracking_id
def test_user_with_no_program_access(self):
"""
Test that a user with no program permissions will raise an exception
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
with self.assertRaises(NoProgramAccessException):
create_search_obj(profile.user)
def test_delete_staff_as_moderator_enabled(mocker, patched_users_api):
"""Test that remove_user_as_moderator_to_channel calls the task if enabled on save"""
mock_task = mocker.patch('discussions.tasks.remove_user_as_moderator_from_channel')
with mute_signals(post_save):
profile = ProfileFactory.create()
role = RoleFactory.create(user=profile.user)
role.delete()
mock_task.delay.assert_called_once_with(role.user_id, role.program_id)
def test_sync_user_profile_disabled(settings, mocker):
"""Test that sync_user_profile doesn't call the api if disabled"""
settings.FEATURES['OPEN_DISCUSSIONS_USER_SYNC'] = False
mock_task = mocker.patch('discussions.tasks.sync_discussion_user')
with mute_signals(post_save):
profile = ProfileFactory.create()
profile.save()
assert mock_task.delay.called is False
def test_missing_profile(self):
"""get_mail_vars should skip User objects without a Profile"""
with mute_signals(post_save):
profile = ProfileFactory.create()
user = profile.user
profile.delete()
assert list(get_mail_vars([user.email])) == []
