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

Delete change_email_request and lang_pref_set_language

cms/urls.py

@@ -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

common/djangoapps/lang_pref/api.py

@@ -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)

common/djangoapps/lang_pref/tests/test_api.py

@@ -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'))

common/djangoapps/lang_pref/tests/test_views.py

-"""
-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))

common/djangoapps/lang_pref/urls.py

-"""
-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')
-)

common/djangoapps/lang_pref/views.py

-"""
-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')

common/djangoapps/student/tests/test_email.py

@@ -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,

common/djangoapps/student/views.py

@@ -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

lms/urls.py

@@ -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