Refactored tests

common/djangoapps/student/tests/tests.py

@@ -15,8 +15,11 @@ from django.test import TestCase
 from django.test.client import RequestFactory
 from django.contrib.auth.models import User
 from django.contrib.auth.hashers import UNUSABLE_PASSWORD
+from django.contrib.auth.tokens import default_token_generator
 from django.template.loader import render_to_string, get_template, TemplateDoesNotExist
 from django.core.urlresolvers import is_valid_path
+from django.utils.http import int_to_base36
+
 
 from mock import Mock, patch
 from textwrap import dedent
@@ -46,36 +49,40 @@ class ResetPasswordTests(TestCase):
         self.user = UserFactory.create()
         self.user.is_active = False
         self.user.save()
+        self.token = default_token_generator.make_token(self.user)
+        self.uidb36 = int_to_base36(self.user.id)
 
         self.user_bad_passwd = UserFactory.create()
         self.user_bad_passwd.is_active = False
         self.user_bad_passwd.password = UNUSABLE_PASSWORD
         self.user_bad_passwd.save()
 
+    def test_user_bad_password_reset(self):
+        """Tests password reset behavior for user with password marked UNUSABLE_PASSWORD"""
 
-    @unittest.skipUnless(project_uses_password_reset, dedent("""Skipping Test because CMS has not provided
-    necessary templates for password reset.  If this message is in LMS tests, that is a bug and needs to be fixed."""))
-    @patch('student.views.password_reset_confirm')
-    @patch('django.core.mail.send_mail')
-    @patch('student.views.render_to_string', Mock(side_effect=mock_render_to_string, autospec=True))
-    def test_reset_password_email(self, send_email, reset_confirm):
-        """Tests sending of reset password email"""
-
-        #First test the bad password user, mainly for diff-cover sake
         bad_pwd_req = self.request_factory.post('/password_reset/', {'email': self.user_bad_passwd.email})
         bad_pwd_resp = password_reset(bad_pwd_req)
         self.assertEquals(bad_pwd_resp.status_code, 200)
         self.assertEquals(bad_pwd_resp.content, json.dumps({'success': False,
                                                             'error': 'Invalid e-mail or user'}))
 
-        #Now test the exception cases with invalid email.
+    def test_nonexist_email_password_reset(self):
+        """Now test the exception cases with of reset_password called with invalid email."""
+
         bad_email_req = self.request_factory.post('/password_reset/', {'email': self.user.email+"makeItFail"})
         bad_email_resp = password_reset(bad_email_req)
         self.assertEquals(bad_email_resp.status_code, 200)
         self.assertEquals(bad_email_resp.content, json.dumps({'success': False,
                                                               'error': 'Invalid e-mail or user'}))
 
-        #Now test the legit case where email should have been sent
+    @unittest.skipUnless(project_uses_password_reset,
+                         dedent("""Skipping Test because CMS has not provided necessary templates for password reset.
+                                If LMS tests print this message, that needs to be fixed."""))
+    @patch('django.core.mail.send_mail')
+    @patch('student.views.render_to_string', Mock(side_effect=mock_render_to_string, autospec=True))
+    def test_reset_password_email(self, send_email):
+        """Tests contents of reset password email, and that user is not active"""
+
         good_req = self.request_factory.post('/password_reset/', {'email': self.user.email})
         good_resp = password_reset(good_req)
         self.assertEquals(good_resp.status_code, 200)
@@ -91,33 +98,35 @@ class ResetPasswordTests(TestCase):
         self.assertIn(self.user.email, to_addrs)
 
         #test that the user is not active
-        #it's a bit unsettling that we have to reload the user from the db for this test to work
-        #but I guess the user is cached here in the instance of ResetPasswordTests
-        #so the update in the view does not know to update this class.
         self.user = User.objects.get(pk=self.user.pk)
         self.assertFalse(self.user.is_active)
+        reset_match = re.search(r'password_reset_confirm/(?P<uidb36>[0-9A-Za-z]+)-(?P<token>.+)/', msg).groupdict()
+
+    @patch('student.views.password_reset_confirm')
+    def test_reset_password_bad_token(self, reset_confirm):
+        """Tests bad token and uidb36 in password reset"""
 
-        #now try to activate the user in the password reset phase
         bad_reset_req = self.request_factory.get('/password_reset_confirm/NO-OP/')
-        bad_reset_resp = password_reset_confirm_wrapper(bad_reset_req, 'NO', 'OP')
+        password_reset_confirm_wrapper(bad_reset_req, 'NO', 'OP')
         (confirm_args, confirm_kwargs) = reset_confirm.call_args
         self.assertEquals(confirm_kwargs['uidb36'], 'NO')
         self.assertEquals(confirm_kwargs['token'], 'OP')
         self.user = User.objects.get(pk=self.user.pk)
         self.assertFalse(self.user.is_active)
 
-        reset_match = re.search(r'password_reset_confirm/(?P<uidb36>[0-9A-Za-z]+)-(?P<token>.+)/', msg).groupdict()
-        good_reset_req = self.request_factory.get('/password_reset_confirm/{0}-{1}/'.format(reset_match['uidb36'],
-                                                                                            reset_match['token']))
-        good_reset_resp = password_reset_confirm_wrapper(good_reset_req, reset_match['uidb36'], reset_match['token'])
+    @patch('student.views.password_reset_confirm')
+    def test_reset_password_good_token(self, reset_confirm):
+        """Tests good token and uidb36 in password reset"""
+
+        good_reset_req = self.request_factory.get('/password_reset_confirm/{0}-{1}/'.format(self.uidb36, self.token))
+        password_reset_confirm_wrapper(good_reset_req, self.uidb36, self.token)
         (confirm_args, confirm_kwargs) = reset_confirm.call_args
-        self.assertEquals(confirm_kwargs['uidb36'], reset_match['uidb36'])
-        self.assertEquals(confirm_kwargs['token'], reset_match['token'])
+        self.assertEquals(confirm_kwargs['uidb36'], self.uidb36)
+        self.assertEquals(confirm_kwargs['token'], self.token)
         self.user = User.objects.get(pk=self.user.pk)
         self.assertTrue(self.user.is_active)
 
 
-
 class CourseEndingTest(TestCase):
     """Test things related to course endings: certificates, surveys, etc"""