Merge pull request #151 from anx-bhagmann/django4-deprecation-fixes

Fix deprecation warnings for Django 4.0 #hacktoberfest

Author: beachmachine

django_rest_passwordreset/signals.py

@@ -1,15 +1,22 @@
-import django.dispatch
+from django.dispatch import Signal
 
 __all__ = [
     'reset_password_token_created',
     'pre_password_reset',
     'post_password_reset',
 ]
 
-reset_password_token_created = django.dispatch.Signal(
-    providing_args=["instance", "reset_password_token"],
-)
+"""
+Signal arguments: instance, reset_password_token
+"""
+reset_password_token_created = Signal()
 
-pre_password_reset = django.dispatch.Signal(providing_args=["user"])
+"""
+Signal arguments: user
+"""
+pre_password_reset = Signal()
 
-post_password_reset = django.dispatch.Signal(providing_args=["user"])
+"""
+Signal arguments: user
+"""
+post_password_reset = Signal()

django_rest_passwordreset/urls.py

@@ -1,33 +1,33 @@
 """ URL Configuration for core auth """
-from django.conf.urls import url
+from django.urls import path
 
-from django_rest_passwordreset.views import ResetPasswordValidateTokenViewSet, ResetPasswordConfirmViewSet, \
-    ResetPasswordRequestTokenViewSet, reset_password_validate_token, reset_password_confirm, \
-    reset_password_request_token
+from django_rest_passwordreset.views import ResetPasswordConfirmViewSet, ResetPasswordRequestTokenViewSet, \
+    ResetPasswordValidateTokenViewSet, reset_password_confirm, reset_password_request_token, \
+    reset_password_validate_token
 
 app_name = 'password_reset'
 
 
 def add_reset_password_urls_to_router(router, base_path=''):
     router.register(
-        base_path + r'/validate_token',
+        base_path + "/validate_token",
         ResetPasswordValidateTokenViewSet,
         basename='reset-password-validate'
     )
     router.register(
-        base_path + r'/confirm',
+        base_path + "/confirm",
         ResetPasswordConfirmViewSet,
         basename='reset-password-confirm'
     )
     router.register(
-        base_path + r'',
+        base_path,
         ResetPasswordRequestTokenViewSet,
         basename='reset-password-request'
     )
 
 
 urlpatterns = [
-    url(r'^validate_token/', reset_password_validate_token, name="reset-password-validate"),
-    url(r'^confirm/', reset_password_confirm, name="reset-password-confirm"),
-    url(r'^', reset_password_request_token, name="reset-password-request"),
+    path("validate_token/", reset_password_validate_token, name="reset-password-validate"),
+    path("confirm/", reset_password_confirm, name="reset-password-confirm"),
+    path("", reset_password_request_token, name="reset-password-request"),
 ]

tests/requirements.txt

@@ -0,0 +1,2 @@
+django>=2.2,<3.3
+djangorestframework>=3.12.4,<3.13

tests/test/test_auth_test_case.py

@@ -1,9 +1,10 @@
 import json
-from django.test import override_settings
+
 from django.contrib.auth.models import User
-from django.db.models import Q
+from django.test import override_settings
 from rest_framework import status
 from rest_framework.test import APITestCase
+
 from django_rest_passwordreset.models import ResetPasswordToken
 from tests.test.helpers import HelperMixin, patch
 
@@ -12,6 +13,7 @@ class AuthTestCase(APITestCase, HelperMixin):
     """
     Several Test Cases for the Multi Auth Token Django App
     """
+
     def setUp(self):
         self.setUpUrls()
         self.user1 = User.objects.create_user("user1", "[email protected]", "secret1")
@@ -72,7 +74,7 @@ def test_validate_bad_token(self):
         # try to validate an invalid token
         response = self.rest_do_validate_token("not_a_valid_token")
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
-        
+
         # there should be zero tokens
         self.assertEqual(ResetPasswordToken.objects.all().count(), 0)
 
@@ -224,21 +226,20 @@ def test_reset_password_multiple_users(self, mock_reset_password_token_created):
         # connect signal
         # we need to check whether the signal is getting called
 
-
         # create a token for user 1
         response = self.rest_do_request_reset_token(email="[email protected]")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(ResetPasswordToken.objects.all().count(), 1)
         self.assertTrue(mock_reset_password_token_created.called)
-        self.assertEquals(mock_reset_password_token_created.call_count, 1)
+        self.assertEqual(mock_reset_password_token_created.call_count, 1)
         token1 = mock_reset_password_token_created.call_args[1]['reset_password_token']
 
         # create another token for user 2
         response = self.rest_do_request_reset_token(email="[email protected]")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         tokens = ResetPasswordToken.objects.all()
         self.assertEqual(tokens.count(), 2)
-        self.assertEquals(mock_reset_password_token_created.call_count, 2)
+        self.assertEqual(mock_reset_password_token_created.call_count, 2)
         token2 = mock_reset_password_token_created.call_args[1]['reset_password_token']
 
         # validate that those two tokens are different
@@ -269,7 +270,7 @@ def test_reset_password_multiple_users(self, mock_reset_password_token_created):
 
         # try to reset again with token2 (should not work)
         response = self.rest_do_reset_password_with_token(token2.key, "secret2_fake_new")
-        self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
 
         # user 2 should still be able to login with "secret2_new" now
         self.assertTrue(
@@ -296,10 +297,11 @@ def test_signals(self,
 
         # verify that the reset_password_token_created signal was fired
         self.assertTrue(mock_reset_password_token_created.called)
-        self.assertEquals(mock_reset_password_token_created.call_count, 1)
+        self.assertEqual(mock_reset_password_token_created.call_count, 1)
 
         token1 = mock_reset_password_token_created.call_args[1]['reset_password_token']
-        self.assertNotEqual(token1.key, "", msg="Verify that the reset_password_token of the reset_password_Token_created signal is not empty")
+        self.assertNotEqual(token1.key, "",
+                            msg="Verify that the reset_password_token of the reset_password_Token_created signal is not empty")
 
         # verify that the other two signals have not yet been called
         self.assertFalse(mock_post_password_reset.called)
@@ -315,12 +317,13 @@ def test_signals(self,
 
     @override_settings(DJANGO_REST_PASSWORDRESET_NO_INFORMATION_LEAKAGE=True)
     def test_try_reset_password_email_does_not_exist_no_leakage_enabled(self):
-        """ 
+        """
         Tests requesting a token for an email that does not exist when
         DJANGO_REST_PASSWORDRESET_NO_INFORMATION_LEAKAGE == True
-        """ 
+        """
         response = self.rest_do_request_reset_token(email="[email protected]")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
+
     def test_user_without_password(self):
         """ Tests requesting a token for an email without a password doesn't work"""
         response = self.rest_do_request_reset_token(email="[email protected]")
@@ -334,7 +337,6 @@ def test_user_without_password(self):
     def test_user_without_password_where_not_required(self, mock_reset_password_token_created):
         """ Tests requesting a token for an email without a password works when not required"""
         response = self.rest_do_request_reset_token(email="[email protected]")
-        decoded_response = json.loads(response.content.decode())
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         # check that the signal was sent once
         self.assertTrue(mock_reset_password_token_created.called)
@@ -372,4 +374,3 @@ def test_user_without_password_where_not_required(self, mock_reset_password_toke
             self.django_check_login("user4", "new_secret"),
             msg="User 4 should be able to login with the modified credentials"
         )
-

tests/test/test_token_generators.py

@@ -1,29 +1,27 @@
-from django.test import TestCase
 from django.conf import settings
+from django.test import TestCase
 
-from django_rest_passwordreset.tokens import RandomStringTokenGenerator, RandomNumberTokenGenerator, get_token_generator
+from django_rest_passwordreset.tokens import RandomNumberTokenGenerator, RandomStringTokenGenerator, get_token_generator
 
 
 class TokenGeneratorTestCase(TestCase):
     """
     Tests that the token generators work as expected
     """
-    def setUp(self):
-        pass
 
     def test_string_token_generator(self):
         token_generator = RandomStringTokenGenerator(min_length=10, max_length=15)
 
         tokens = []
 
         # generate 100 tokens
-        for i in range(0, 100):
+        for _ in range(0, 100):
             tokens.append(token_generator.generate_token())
 
         # validate that those 100 tokens are unique
         unique_tokens = list(set(tokens))
 
-        self.assertEquals(
+        self.assertEqual(
             len(tokens), len(unique_tokens), msg="StringTokenGenerator must create unique tokens"
         )
         ################################################################################################################
@@ -46,13 +44,13 @@ def test_number_token_generator(self):
         tokens = []
 
         # generate 100 tokens
-        for i in range(0, 100):
+        for _ in range(0, 100):
             tokens.append(token_generator.generate_token())
 
         # validate that those 100 tokens are unique
         unique_tokens = list(set(tokens))
 
-        self.assertEquals(
+        self.assertEqual(
             len(tokens), len(unique_tokens), msg="RandomNumberTokenGenerator must create unique tokens"
         )
         ################################################################################################################
@@ -62,18 +60,15 @@ def test_number_token_generator(self):
 
         # validate that each token is a number between 100000 and 999999
         for token in tokens:
-            is_number = False
             try:
                 num = int(token)
-                is_number = True
             except:
-                is_number = False
-
-            self.assertEquals(is_number, True, msg="RandomNumberTokenGenerator must return a number, but returned "
-                                                   + token)
+                self.fail("RandomNumberTokenGenerator must return a number, but returned " + token)
 
-            self.assertGreaterEqual(num, 1000000000, msg="RandomNumberTokenGenerator must return a number greater or equal to 1000000000")
-            self.assertLess(num, 9999999999, msg="RandomNumberTokenGenerator must return a number less or equal to 9999999999")
+            self.assertGreaterEqual(num, 1000000000,
+                                    msg="RandomNumberTokenGenerator must return a number greater or equal to 1000000000")
+            self.assertLess(num, 9999999999,
+                            msg="RandomNumberTokenGenerator must return a number less or equal to 9999999999")
 
     def test_generate_token_generator_from_empty_settings(self):
         """
@@ -86,7 +81,7 @@ def test_generate_token_generator_from_empty_settings(self):
 
         token_generator = get_token_generator()
 
-        self.assertEquals(
+        self.assertEqual(
             token_generator.__class__, RandomStringTokenGenerator,
             msg="If no class is set in DJANGO_REST_PASSWORDRESET_TOKEN_CONFIG, a RandomStringTokenGenerator should"
                 "be created"
@@ -104,7 +99,7 @@ def test_generate_token_generator_from_settings_string_token_generator(self):
 
         token_generator = get_token_generator()
 
-        self.assertEquals(
+        self.assertEqual(
             token_generator.__class__, RandomStringTokenGenerator,
             msg="get_token_generator() should return an instance of RandomStringTokenGenerator "
                 "if configured in settings"
@@ -122,7 +117,7 @@ def test_generate_token_generator_from_settings_number_token_generator(self):
 
         token_generator = get_token_generator()
 
-        self.assertEquals(
+        self.assertEqual(
             token_generator.__class__, RandomNumberTokenGenerator,
             msg="get_token_generator() should return an instance of RandomNumberTokenGenerator "
                 "if configured in settings"

tests/urls.py

@@ -1,9 +1,9 @@
 """ Tests App URL Config """
-from django.conf.urls import url, include
+from django.conf.urls import include
 from django.contrib import admin
-
+from django.urls import path
 
 urlpatterns = [
-    url(r'^api/password_reset/', include('django_rest_passwordreset.urls', namespace='password_reset')),
-    url(r'^admin/', admin.site.urls),
+    path("api/password_reset/", include('django_rest_passwordreset.urls', namespace='password_reset')),
+    path("admin/", admin.site.urls),
 ]