Andal.LND/edx-platform
6
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #8306 from edx/christina/delete-unused-methods

Browse Source 
Delete change_email_request and lang_pref_set_language
This commit is contained in:
Christina Roberts
2015-06-02 11:30:35 -04:00
parent e8022c74f2 410beb8485
commit 46cb847eb9
9 changed files with 34 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cms/urls.py
View File

@@ -50,7 +50,6 @@ urlpatterns = patterns(
url(r'^heartbeat$', include('heartbeat.urls')),
url(r'^user_api/', include('openedx.core.djangoapps.user_api.legacy_urls')),
url(r'^lang_pref/', include('lang_pref.urls')),
)
# User creation and updating views

36
common/djangoapps/lang_pref/api.py
View File

@@ -4,7 +4,6 @@
from collections import namedtuple
from django.conf import settings
from django.utils.translation import get_language
from dark_lang.models import DarkLangConfig
@@ -46,38 +45,3 @@ def released_languages():
]
return released_languages
def preferred_language(preferred_language_code):
"""Retrieve the name of the user's preferred language.
Note:
The preferred_language_code may be None. If this is the case,
the if/else block will handle it by returning either the active
language or the default language.
Args:
preferred_language_code (str): The ISO 639 code corresponding
to the user's preferred language.
Returns:
unicode: The name of the user's preferred language.
"""
active_language_code = get_language()
if preferred_language_code in settings.LANGUAGE_DICT:
# If the user has indicated a preference for a valid
# language, record their preferred language
pass
elif active_language_code in settings.LANGUAGE_DICT:
# Otherwise, set the language used in the current thread
# as the preferred language
preferred_language_code = active_language_code
else:
# Otherwise, use the default language
preferred_language_code = settings.LANGUAGE_CODE
preferred_language = settings.LANGUAGE_DICT[preferred_language_code]
return Language(preferred_language_code, preferred_language)

18
common/djangoapps/lang_pref/tests/test_api.py
View File

@@ -2,29 +2,11 @@
""" Tests for the language API. """
from django.test import TestCase
import ddt
from lang_pref import api as language_api
@ddt.ddt
class LanguageApiTest(TestCase):
INVALID_LANGUAGE_CODES = ['', 'foo']
def test_released_languages(self):
released_languages = language_api.released_languages()
self.assertGreaterEqual(len(released_languages), 1)
def test_preferred_language(self):
preferred_language = language_api.preferred_language('fr')
self.assertEqual(preferred_language, language_api.Language('fr', u'Français'))
@ddt.data(*INVALID_LANGUAGE_CODES)
def test_invalid_preferred_language(self, language_code):
preferred_language = language_api.preferred_language(language_code)
self.assertEqual(preferred_language, language_api.Language('en', u'English'))
def test_no_preferred_language(self):
preferred_language = language_api.preferred_language(None)
self.assertEqual(preferred_language, language_api.Language('en', u'English'))

34
common/djangoapps/lang_pref/tests/test_views.py
View File

@@ -1,34 +0,0 @@
"""
Tests for the language setting view
"""
from django.core.urlresolvers import reverse
from django.test import TestCase
from student.tests.factories import UserFactory
from openedx.core.djangoapps.user_api.preferences.api import get_user_preference
from lang_pref import LANGUAGE_KEY
class TestLanguageSetting(TestCase):
"""
Test setting languages
"""
def test_set_preference_happy(self):
user = UserFactory.create()
self.client.login(username=user.username, password='test')
lang = 'en'
response = self.client.post(reverse('lang_pref_set_language'), {'language': lang})
self.assertEquals(response.status_code, 200)
user_pref = get_user_preference(user, LANGUAGE_KEY)
self.assertEqual(user_pref, lang)
def test_set_preference_missing_lang(self):
user = UserFactory.create()
self.client.login(username=user.username, password='test')
response = self.client.post(reverse('lang_pref_set_language'))
self.assertEquals(response.status_code, 400)
self.assertIsNone(get_user_preference(user, LANGUAGE_KEY))

10
common/djangoapps/lang_pref/urls.py
View File

@@ -1,10 +0,0 @@
"""
Urls for managing language preferences
"""
from django.conf.urls import patterns, url
urlpatterns = patterns(
'',
url(r'^setlang/', 'lang_pref.views.set_language', name='lang_pref_set_language')
)

22
common/djangoapps/lang_pref/views.py
View File

@@ -1,22 +0,0 @@
"""
Views for accessing language preferences
"""
from django.contrib.auth.decorators import login_required
from django.http import HttpResponse, HttpResponseBadRequest
from openedx.core.djangoapps.user_api.preferences.api import set_user_preference
from lang_pref import LANGUAGE_KEY
@login_required
def set_language(request):
"""
This view is called when the user would like to set a language preference
"""
lang_pref = request.POST.get('language', None)
if lang_pref:
set_user_preference(request.user, LANGUAGE_KEY, lang_pref)
return HttpResponse('{"success": true}')
return HttpResponseBadRequest('no language provided')

93
common/djangoapps/student/tests/test_email.py
View File

@@ -5,8 +5,8 @@ import unittest
from student.tests.factories import UserFactory, RegistrationFactory, PendingEmailChangeFactory
from student.views import (
reactivation_email_for_user, change_email_request, do_email_change_request, confirm_email_change,
SETTING_CHANGE_INITIATED
reactivation_email_for_user, do_email_change_request, confirm_email_change,
validate_new_email, SETTING_CHANGE_INITIATED
)
from student.models import UserProfile, PendingEmailChange
from django.core.urlresolvers import reverse
@@ -216,16 +216,19 @@ class EmailChangeRequestTests(EventTestMixin, TestCase):
self.request.user = self.user
self.user.email_user = Mock()
def run_request(self, request=None):
"""Execute request and return result parsed as json
def do_email_validation(self, email):
"""Executes validate_new_email, returning any resulting error message. """
try:
validate_new_email(self.request.user, email)
except ValueError as err:
return err.message
If request isn't passed in, use self.request instead
"""
if request is None:
request = self.request
response = change_email_request(self.request)
return json.loads(response.content)
def do_email_change(self, user, email, activation_key=None):
"""Executes do_email_change_request, returning any resulting error message. """
try:
do_email_change_request(user, email, activation_key)
except ValueError as err:
return err.message
def assertFailedRequest(self, response_data, expected_error):
"""Assert that `response_data` indicates a failed request that returns `expected_error`"""
@@ -233,78 +236,50 @@ class EmailChangeRequestTests(EventTestMixin, TestCase):
self.assertEquals(expected_error, response_data['error'])
self.assertFalse(self.user.email_user.called)
def test_unauthenticated(self):
self.request.user = AnonymousUser()
self.request.user.email_user = Mock()
with self.assertRaises(Http404):
change_email_request(self.request)
self.assertFalse(self.request.user.email_user.called)
def test_invalid_password(self):
self.request.POST['password'] = 'wrong'
self.assertFailedRequest(self.run_request(), 'Invalid password')
@patch('student.views.render_to_string', Mock(side_effect=mock_render_to_string, autospec=True))
def test_duplicate_activation_key(self):
"""Assert that if two users change Email address simultaneously, server should return 200"""
"""Assert that if two users change Email address simultaneously, no error is thrown"""
# New emails for the users
user1_new_email = "valid_user1_email@example.com"
user2_new_email = "valid_user2_email@example.com"
# Set new email for user1.
self.request.POST['new_email'] = user1_new_email
# Create a another user 'user2' & make request for change email
user2 = UserFactory.create(email=self.new_email, password="test2")
user2_request = self.req_factory.post('unused_url', data={
'password': 'test2',
'new_email': user2_new_email
})
user2_request.user = user2
# Send requests & check if response was successful
user1_response = change_email_request(self.request)
user2_response = change_email_request(user2_request)
self.assertEqual(user1_response.status_code, 200)
self.assertEqual(user2_response.status_code, 200)
# Send requests & ensure no error was thrown
self.assertIsNone(self.do_email_change(self.user, user1_new_email))
self.assertIsNone(self.do_email_change(user2, user2_new_email))
def test_invalid_emails(self):
"""
Assert the expected error message from the email validation method for an invalid
(improperly formatted) email address.
"""
for email in ('bad_email', 'bad_email@', '@bad_email'):
self.request.POST['new_email'] = email
self.assertFailedRequest(self.run_request(), 'Valid e-mail address required.')
self.assertEqual(self.do_email_validation(email), 'Valid e-mail address required.')
def test_change_email_to_existing_value(self):
""" Test the error message if user attempts to change email to the existing value. """
self.request.POST['new_email'] = self.user.email
self.assertFailedRequest(self.run_request(), 'Old email is the same as the new email.')
def check_duplicate_email(self, email):
"""Test that a request to change a users email to `email` fails"""
request = self.req_factory.post('unused_url', data={
'new_email': email,
'password': 'test',
})
request.user = self.user
self.assertFailedRequest(self.run_request(request), 'An account with this e-mail already exists.')
self.assertEqual(self.do_email_validation(self.user.email), 'Old email is the same as the new email.')
def test_duplicate_email(self):
"""
Assert the expected error message from the email validation method for an email address
that is already in use by another account.
"""
UserFactory.create(email=self.new_email)
self.check_duplicate_email(self.new_email)
def test_capitalized_duplicate_email(self):
"""Test that we check for email addresses in a case insensitive way"""
UserFactory.create(email=self.new_email)
self.check_duplicate_email(self.new_email.capitalize())
self.assertEqual(self.do_email_validation(self.new_email), 'An account with this e-mail already exists.')
@patch('django.core.mail.send_mail')
@patch('student.views.render_to_string', Mock(side_effect=mock_render_to_string, autospec=True))
def test_email_failure(self, send_mail):
""" Test the return value if sending the email for the user to click fails. """
send_mail.side_effect = [Exception, None]
self.request.POST['new_email'] = "valid@email.com"
self.assertFailedRequest(self.run_request(), 'Unable to send email activation link. Please try again later.')
self.assertEqual(
self.do_email_change(self.user, "valid@email.com"),
'Unable to send email activation link. Please try again later.'
)
self.assert_no_events_were_emitted()
@patch('django.core.mail.send_mail')
@@ -314,7 +289,7 @@ class EmailChangeRequestTests(EventTestMixin, TestCase):
old_email = self.user.email
new_email = "valid@example.com"
registration_key = "test registration key"
do_email_change_request(self.user, new_email, registration_key)
self.assertIsNone(self.do_email_change(self.user, new_email, registration_key))
context = {
'key': registration_key,
'old_email': old_email,

30
common/djangoapps/student/views.py
View File

@@ -1970,36 +1970,6 @@ def reactivation_email_for_user(user):
return JsonResponse({"success": True})
# TODO: delete this method and redirect unit tests to validate_new_email and do_email_change_request
# after accounts page work is done.
@ensure_csrf_cookie
def change_email_request(request):
""" AJAX call from the profile page. User wants a new e-mail.
"""
## Make sure it checks for existing e-mail conflicts
if not request.user.is_authenticated():
raise Http404
user = request.user
if not user.check_password(request.POST['password']):
return JsonResponse({
"success": False,
"error": _('Invalid password'),
}) # TODO: this should be status code 400 # pylint: disable=fixme
new_email = request.POST['new_email']
try:
validate_new_email(request.user, new_email)
do_email_change_request(request.user, new_email)
except ValueError as err:
return JsonResponse({
"success": False,
"error": err.message,
})
return JsonResponse({"success": True})
def validate_new_email(user, new_email):
"""
Given a new email for a user, does some basic verification of the new address If any issues are encountered

3
lms/urls.py
View File

@@ -28,7 +28,6 @@ urlpatterns = (
url(r'^admin_dashboard$', 'dashboard.views.dashboard'),
url(r'^change_email$', 'student.views.change_email_request', name="change_email"),
url(r'^email_confirm/(?P<key>[^/]*)$', 'student.views.confirm_email_change'),
url(r'^change_name$', 'student.views.change_name_request', name="change_name"),
url(r'^event$', 'track.views.user_track'),
@@ -68,8 +67,6 @@ urlpatterns = (
url(r'^notifier_api/', include('notifier_api.urls')),
url(r'^lang_pref/', include('lang_pref.urls')),
url(r'^i18n/', include('django.conf.urls.i18n')),
# Feedback Form endpoint