def test_update_profile(self):
"""
Happy path
"""
mocked_content = self.mocked_edx_profile
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()),
self.user, {'access_token': 'foo_token'}, True, **{'edx_profile': mocked_content}
)
first_name, last_name = split_name(mocked_content['name'])
all_fields = [
('account_privacy', Profile.PUBLIC_TO_MM),
('edx_name', mocked_content['name']),
('first_name', first_name),
('last_name', last_name),
('preferred_name', mocked_content['name']),
('edx_bio', mocked_content['bio']),
('country', mocked_content['country']),
('edx_requires_parental_consent', mocked_content['requires_parental_consent']),
('edx_level_of_education', mocked_content['level_of_education']),
('edx_goals', mocked_content['goals']),
('edx_language_proficiencies', mocked_content['language_proficiencies']),
('preferred_language', mocked_content['language_proficiencies'][0]['code']),
('gender', mocked_content['gender']),
('edx_mailing_address', mocked_content['mailing_address']),
]
self.check_profile_fields(self.user_profile, all_fields)
# We do not set the date_of_birth using year_of_birth
assert self.user_profile.date_of_birth is None
def test_update_profile_old_user(self):
"""
Only new users are updated
"""
self.check_empty_profile(self.user_profile)
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2, self.user, {'access_token': 'foo'}, False)
self.user_profile.refresh_from_db()
self.check_empty_profile(self.user_profile)
def test_update_email(self, is_new):
"""
Test email changed for new user.
"""
mocked_content = {'email': '*****@*****.**'}
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()), self.user,
{'access_token': 'foo_token'}, is_new,
**{'edx_profile': mocked_content})
assert self.user.email == mocked_content['email']
def test_login_redirect_dashboard(self):
"""
A student should be directed to /dashboard
"""
student = UserFactory.create()
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(backend, student, {}, False, **{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', '/dashboard')
def test_update_profile_no_access_token(self):
"""
The response dict has no access token
"""
self.check_empty_profile(self.user_profile)
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2, self.user, {'access_token': ''}, True)
self.user_profile.refresh_from_db()
self.check_empty_profile(self.user_profile)
def test_update_profile_wrong_backend(self):
"""
The only backend allowed for update_profile is edxorg
"""
self.check_empty_profile(self.user_profile)
backend = mock.MagicMock(name='other_backend')
pipeline_api.update_profile_from_edx(
backend, self.user, {'access_token': 'foo'}, True)
self.user_profile.refresh_from_db()
self.check_empty_profile(self.user_profile)
def test_update_profile_old_user(self):
"""
Only new users are updated
"""
self.check_empty_profile(self.user_profile)
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()),
self.user, {'access_token': 'foo'}, False, **{'edx_profile': self.mocked_edx_profile}
)
self.user_profile.refresh_from_db()
self.check_empty_profile(self.user_profile)
def test_update_profile_old_user(self):
"""
Only new users are updated
"""
self.check_empty_profile(self.user_profile)
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()), self.user,
{'access_token': 'foo'}, False,
**{'edx_profile': self.mocked_edx_profile})
self.user_profile.refresh_from_db()
self.check_empty_profile(self.user_profile)
def test_login_redirect_next_for_user_already_logged_in(self):
"""
A student should be directed to what's in the next query parameter if user is already logged in to MM.
"""
student = UserFactory.create()
next_url = "/discussion"
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = next_url
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(backend, student, {}, False, **{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', next_url)
def test_login_redirect_next(self):
"""
A student should be directed to what's in the next query parameter
"""
student = UserFactory.create()
next_url = "/x/y?a=bc"
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {"next": next_url}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(backend, student, {}, False, **{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', next_url)
def test_update_profile_wrong_backend(self):
"""
The only backend allowed for update_profile is edxorg
"""
self.check_empty_profile(self.user_profile)
backend = mock.MagicMock(name='other_backend')
pipeline_api.update_profile_from_edx(
backend, self.user, {'access_token': 'foo'}, True)
self.user_profile.refresh_from_db()
self.check_empty_profile(self.user_profile)
def test_login_redirect_dashboard(self):
"""
A student should be directed to /dashboard
"""
student = UserFactory.create()
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(
backend, student, {}, False,
**{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', '/dashboard')
def test_login_redirect_learners(self):
"""
Staff or instructors should be directed to /learners
"""
for role in [Staff.ROLE_ID, Instructor.ROLE_ID]:
user = UserFactory.create()
Role.objects.create(user=user, role=role, program=ProgramFactory.create())
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(backend, user, {}, False, **{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', '/learners')
def test_update_email(self, is_new):
"""
Test email changed for new user.
"""
mocked_content = {
'email': '*****@*****.**'
}
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()),
self.user, {'access_token': 'foo_token'}, is_new, **{'edx_profile': mocked_content}
)
assert self.user.email == mocked_content['email']
def test_login_redirect_next(self):
"""
A student should be directed to what's in the next query parameter
"""
student = UserFactory.create()
next_url = "/x/y?a=bc"
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {"next": next_url}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(
backend, student, {}, False,
**{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', next_url)
def test_login_redirect_next_for_user_already_logged_in(self):
"""
A student should be directed to what's in the next query parameter if user is already logged in to MM.
"""
student = UserFactory.create()
next_url = "/discussion"
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = next_url
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(
backend, student, {}, False,
**{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', next_url)
def test_preferred_language(self, mocked_get_json):
"""
If language_proficiencies is missing or invalid, we should not set
preferred_language. We already test the success case in test_update_profile
"""
for proficiencies in ([], {}, [{}], None):
mocked_content = dict(self.mocked_edx_profile)
mocked_content['language_proficiencies'] = proficiencies
mocked_get_json.return_value = mocked_content
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2, self.user, {'access_token': 'foo_token'}, True)
self.user_profile.refresh_from_db()
assert self.user_profile.preferred_language is None
assert self.user_profile.edx_language_proficiencies == proficiencies
def test_update_profile_no_existing_profile(self):
"""
The profile did not exist for the user
"""
self.user_profile.delete()
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(user=self.user)
# just checking that nothing raises an exception
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2, self.user, {'access_token': 'foo_token'}, True)
# verify that a profile has not been created
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(user=self.user)
def test_preferred_language(self):
"""
If language_proficiencies is missing or invalid, we should not set
preferred_language. We already test the success case in test_update_profile
"""
for proficiencies in ([], {}, [{}], None):
mocked_content = dict(self.mocked_edx_profile)
mocked_content['language_proficiencies'] = proficiencies
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()),
self.user, {'access_token': 'foo_token'}, True, **{'edx_profile': mocked_content}
)
self.user_profile.refresh_from_db()
assert self.user_profile.preferred_language is None
assert self.user_profile.edx_language_proficiencies == proficiencies
def test_login_redirect_learners(self):
"""
Staff or instructors should be directed to /learners
"""
for role in [Staff.ROLE_ID, Instructor.ROLE_ID]:
user = UserFactory.create()
Role.objects.create(user=user,
role=role,
program=ProgramFactory.create())
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(
backend, user, {}, False,
**{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', '/learners')
def test_update_profile_no_existing_profile(self):
"""
The profile did not exist for the user
"""
self.user_profile.delete()
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(user=self.user)
# just checking that nothing raises an exception
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()),
self.user, {'access_token': 'foo_token'}, True, **{'edx_profile': self.mocked_edx_profile}
)
# verify that a profile has not been created
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(user=self.user)
def test_update_profile(self, mocked_get_json):
"""
Happy path
"""
mocked_content = self.mocked_edx_profile
mocked_get_json.return_value = mocked_content
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2, self.user, {'access_token': 'foo_token'}, True)
mocked_get_json.assert_called_once_with(
urljoin(
edxorg.EdxOrgOAuth2.EDXORG_BASE_URL,
'/api/user/v1/accounts/{0}'.format(get_social_username(self.user))
),
headers={'Authorization': 'Bearer foo_token'}
)
first_name, last_name = split_name(mocked_content['name'])
all_fields = [
('account_privacy', Profile.PUBLIC_TO_MM),
('edx_name', mocked_content['name']),
('first_name', first_name),
('last_name', last_name),
('preferred_name', None),
('edx_bio', mocked_content['bio']),
('country', mocked_content['country']),
('has_profile_image', mocked_content['profile_image']['has_image']),
('edx_requires_parental_consent', mocked_content['requires_parental_consent']),
('edx_level_of_education', mocked_content['level_of_education']),
('edx_goals', mocked_content['goals']),
('edx_language_proficiencies', mocked_content['language_proficiencies']),
('preferred_language', mocked_content['language_proficiencies'][0]['code']),
('gender', mocked_content['gender']),
('edx_mailing_address', mocked_content['mailing_address']),
]
self.check_profile_fields(self.user_profile, all_fields)
# We do not set the date_of_birth using year_of_birth
assert self.user_profile.date_of_birth is None
def test_update_profile(self):
"""
Happy path
"""
mocked_content = self.mocked_edx_profile
pipeline_api.update_profile_from_edx(
edxorg.EdxOrgOAuth2(strategy=mock.Mock()), self.user,
{'access_token': 'foo_token'}, True,
**{'edx_profile': mocked_content})
first_name, last_name = split_name(mocked_content['name'])
all_fields = [
('account_privacy', Profile.PUBLIC_TO_MM),
('edx_name', mocked_content['name']),
('first_name', first_name),
('last_name', last_name),
('preferred_name', mocked_content['name']),
('edx_bio', mocked_content['bio']),
('country', mocked_content['country']),
('edx_requires_parental_consent',
mocked_content['requires_parental_consent']),
('edx_level_of_education', mocked_content['level_of_education']),
('edx_goals', mocked_content['goals']),
('edx_language_proficiencies',
mocked_content['language_proficiencies']),
('preferred_language',
mocked_content['language_proficiencies'][0]['code']),
('gender', mocked_content['gender']),
('edx_mailing_address', mocked_content['mailing_address']),
]
self.check_profile_fields(self.user_profile, all_fields)
# We do not set the date_of_birth using year_of_birth
assert self.user_profile.date_of_birth is None
