Remove django 4.0 deprecations

.travis.yml

@@ -1,5 +1,4 @@
-sudo: false
-
+os: linux
 dist: bionic
 language: python
 
@@ -15,17 +14,21 @@ env:
   # so we don't need to explicitly specify the GNUPG_BINARY setting,
   # and we also want to ensure that the code works without that setting
   # explicitly set (to bump coverage results without excluding that code).
-  - DJANGO_VERSION="Django>=2.0,<2.1" GNUPG_BINARY=/usr/bin/gpg1
-  - DJANGO_VERSION="Django>=2.0,<2.1"
+  - DJANGO_VERSION="Django>=2.2,<3.0" GNUPG_BINARY=/usr/bin/gpg1
+  - DJANGO_VERSION="Django>=2.2,<3.0"
   - DJANGO_VERSION="Django>=3.0,<3.1" GNUPG_BINARY=/usr/bin/gpg1
   - DJANGO_VERSION="Django>=3.0,<3.1"
+  - DJANGO_VERSION="Django>=3.1,<3.2" GNUPG_BINARY=/usr/bin/gpg1
+  - DJANGO_VERSION="Django>=3.1,<3.2"
   - DJANGO_VERSION='https://github.com/django/django/archive/master.tar.gz' GNUPG_BINARY=/usr/bin/gpg1
   - DJANGO_VERSION='https://github.com/django/django/archive/master.tar.gz'
+
 python:
   - "3.6"
   - "3.7"
   - "3.8"
-matrix:
+
+jobs:
   allow_failures:
     - env: DJANGO_VERSION='https://github.com/django/django/archive/master.tar.gz' GNUPG_BINARY=/usr/bin/gpg1
     - env: DJANGO_VERSION='https://github.com/django/django/archive/master.tar.gz'
@@ -39,6 +42,7 @@ before_script:
   - ${GNUPG_BINARY:-gpg} --version
   - mkdir gpg_keyring
 script:
+  - export PYTHONWARNINGS=always
   - flake8 secure_mail --exclude=secure_mail/migrations
   - coverage run manage.py migrate
   - coverage run manage.py test tests

secure_mail/backends.py

@@ -5,7 +5,7 @@
 from django.core.mail.backends.filebased import EmailBackend as FileBackend
 from django.core.mail.backends.smtp import EmailBackend as SmtpBackend
 from django.core.mail.message import EmailMultiAlternatives
-from django.utils.encoding import smart_text
+from django.utils.encoding import smart_str
 
 from .handlers import (handle_failed_message_encryption,
                        handle_failed_alternative_encryption,
@@ -37,11 +37,11 @@ def copy_message(msg):
 
 def encrypt(text, addr):
     encryption_result = gpg.encrypt(text, addr, **encrypt_kwargs)
-    if not encryption_result.ok or (smart_text(encryption_result) == ""
+    if not encryption_result.ok or (smart_str(encryption_result) == ""
                                     and text != ""):
         raise EncryptionFailedError("Encrypting mail to %s failed: '%s'",
                                     addr, encryption_result.status)
-    return smart_text(encryption_result)
+    return smart_str(encryption_result)
 
 
 def encrypt_attachment(address, attachment, use_asc):

secure_mail/forms.py

@@ -1,6 +1,6 @@
 
 from django import forms
-from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import gettext_lazy as _
 
 from secure_mail.models import Key
 from secure_mail.utils import get_gpg

secure_mail/management/commands/email_signing_key.py

@@ -5,7 +5,7 @@
 import warnings
 
 from django.core.management.base import LabelCommand, CommandError
-from django.utils.translation import ugettext as _
+from django.utils.translation import gettext as _
 
 from secure_mail.models import Key
 from secure_mail.settings import SIGNING_KEY_DATA

secure_mail/models.py

@@ -1,5 +1,5 @@
 from django.db import models
-from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import gettext_lazy as _
 
 from secure_mail.settings import SIGNING_KEY_PASSPHRASE
 from secure_mail.utils import addresses_for_key, get_gpg

tests/integration/test_backends.py

@@ -61,16 +61,16 @@ def test_send_mail_function_html_message_encrypted_alternative(self):
 
         # Decrypt and test the alternatives later, just ensure we have
         # any alternatives at all so we fail quickly
-        self.assertNotEquals(message.alternatives, [])
-        self.assertEquals(message.attachments, [])
+        self.assertNotEqual(message.alternatives, [])
+        self.assertEqual(message.attachments, [])
 
         # We should only have one alternative - the txt message
-        self.assertEquals(len(message.alternatives), 1)
+        self.assertEqual(len(message.alternatives), 1)
 
         # Check the alternative to make sure it wasn't encrypted
         content, mimetype = message.alternatives[0]
-        self.assertEquals(mimetype, "application/gpg-encrypted")
-        self.assertEquals(content, alt)
+        self.assertEqual(mimetype, "application/gpg-encrypted")
+        self.assertEqual(content, alt)
 
     def test_handle_failed_alternative_encryption(self):
         msg_subject = "Test Subject"
@@ -141,15 +141,15 @@ def test_send_mail_function_txt_message(self):
 
         message = mail.outbox[0]
 
-        self.assertEquals(message.subject, msg_subject)
+        self.assertEqual(message.subject, msg_subject)
         # We decrypt and test the message body below, these just ensure the
         # message body is not cleartext
-        self.assertEquals(message.body, msg_text)
-        self.assertEquals(message.to, to)
-        self.assertEquals(message.cc, [])
-        self.assertEquals(message.bcc, [])
-        self.assertEquals(message.reply_to, [])
-        self.assertEquals(message.from_email, from_email)
-        self.assertEquals(message.extra_headers, {})
-        self.assertEquals(message.alternatives, [])
-        self.assertEquals(message.attachments, [])
+        self.assertEqual(message.body, msg_text)
+        self.assertEqual(message.to, to)
+        self.assertEqual(message.cc, [])
+        self.assertEqual(message.bcc, [])
+        self.assertEqual(message.reply_to, [])
+        self.assertEqual(message.from_email, from_email)
+        self.assertEqual(message.extra_headers, {})
+        self.assertEqual(message.alternatives, [])
+        self.assertEqual(message.attachments, [])

tests/integration/test_command.py

@@ -16,7 +16,7 @@ def _generate_signing_key(self):
         out = StringIO()
         err = StringIO()
 
-        self.assertEquals(Key.objects.count(), 0)
+        self.assertEqual(Key.objects.count(), 0)
 
         call_command('email_signing_key', '--generate', '--passphrase', '""',
                      stdout=out, stderr=err)
@@ -26,18 +26,18 @@ def _generate_signing_key(self):
         fp, header, *blocks, footer = key_data
 
         self.assertRegex(fp, r'^[0-9A-F]{40}$')
-        self.assertEquals(header, "-----BEGIN PGP PUBLIC KEY BLOCK-----")
-        self.assertEquals(footer, "-----END PGP PUBLIC KEY BLOCK-----")
+        self.assertEqual(header, "-----BEGIN PGP PUBLIC KEY BLOCK-----")
+        self.assertEqual(footer, "-----END PGP PUBLIC KEY BLOCK-----")
 
-        self.assertEquals(err.getvalue(), '')
+        self.assertEqual(err.getvalue(), '')
 
-        self.assertEquals(Key.objects.count(), 1)
+        self.assertEqual(Key.objects.count(), 1)
 
         key = Key.objects.get()
 
         key_data = [header, *blocks, footer]
 
-        self.assertEquals(key.key.strip(), '\n'.join(key_data))
+        self.assertEqual(key.key.strip(), '\n'.join(key_data))
 
         self.fp = fp
 
@@ -47,7 +47,7 @@ def _delete(self, key):
 
         key.delete()
 
-        self.assertEquals(Key.objects.count(), 0)
+        self.assertEqual(Key.objects.count(), 0)
 
     def test_generated_signing_key(self):
         self._generate_signing_key()
@@ -70,12 +70,12 @@ def test_print_private_key(self):
         # The "Version" header key is not required:
         # https://security.stackexchange.com/a/46609
         # self.assertRegex(version, r'^Version: .*$')
-        self.assertEquals(header, "-----BEGIN PGP PRIVATE KEY BLOCK-----")
-        self.assertEquals(footer, "-----END PGP PRIVATE KEY BLOCK-----")
+        self.assertEqual(header, "-----BEGIN PGP PRIVATE KEY BLOCK-----")
+        self.assertEqual(footer, "-----END PGP PRIVATE KEY BLOCK-----")
 
-        self.assertEquals(print_err.getvalue(), '')
+        self.assertEqual(print_err.getvalue(), '')
 
-        self.assertEquals(Key.objects.count(), 1)
+        self.assertEqual(Key.objects.count(), 1)
 
         self._delete(Key.objects.get())
 
@@ -101,11 +101,11 @@ def fake_upload_keys(keyservers, fingerprint):
         call_command('email_signing_key', self.fp, '--keyserver', 'localhost',
                      stdout=upload_out, stderr=upload_err)
 
-        self.assertEquals(data['keyservers'], 'localhost')
-        self.assertEquals(data['fingerprint'], self.fp)
+        self.assertEqual(data['keyservers'], 'localhost')
+        self.assertEqual(data['fingerprint'], self.fp)
 
-        self.assertEquals(upload_out.getvalue(), '')
-        self.assertEquals(upload_err.getvalue(), '')
+        self.assertEqual(upload_out.getvalue(), '')
+        self.assertEqual(upload_err.getvalue(), '')
 
         email_signing_key.upload_keys = previous_value
 
@@ -118,14 +118,14 @@ def test_fingerprint_and_generate_flag_raises_error(self):
         rgx = re.compile(r'^You cannot specify fingerprints and --generate '
                          r'when running this command$')
 
-        self.assertEquals(Key.objects.count(), 0)
+        self.assertEqual(Key.objects.count(), 0)
 
         with self.assertRaisesRegex(CommandError, rgx):
             call_command('email_signing_key', TEST_KEY_FINGERPRINT,
                          generate=True, stdout=out, stderr=err)
 
-        self.assertEquals(out.getvalue(), '')
-        self.assertEquals(err.getvalue(), '')
+        self.assertEqual(out.getvalue(), '')
+        self.assertEqual(err.getvalue(), '')
 
     def test_no_matching_fingerprint_raises_error(self):
         out = StringIO()
@@ -135,11 +135,11 @@ def test_no_matching_fingerprint_raises_error(self):
         rgx = re.compile(r'''^Key matching fingerprint '{fp}' not '''
                          r'''found.$'''.format(fp=missing_fingerprint))
 
-        self.assertEquals(Key.objects.count(), 0)
+        self.assertEqual(Key.objects.count(), 0)
 
         with self.assertRaisesRegex(CommandError, rgx):
             call_command('email_signing_key', missing_fingerprint,
                          stdout=out, stderr=err)
 
-        self.assertEquals(out.getvalue(), '')
-        self.assertEquals(err.getvalue(), '')
+        self.assertEqual(out.getvalue(), '')
+        self.assertEqual(err.getvalue(), '')

tests/integration/test_forms.py

@@ -25,9 +25,9 @@ def test_valid_key_data(self):
             'use_asc': False,
         })
         self.assertTrue(form.is_valid())
-        self.assertEquals(form.cleaned_data['key'].strip(),
+        self.assertEqual(form.cleaned_data['key'].strip(),
                           TEST_PUBLIC_KEY.strip())
-        self.assertEquals(form.cleaned_data['use_asc'], False)
+        self.assertEqual(form.cleaned_data['use_asc'], False)
 
     def test_invalid_key_data(self):
         form = KeyForm(data={

tests/integration/test_handlers.py

@@ -27,7 +27,7 @@ def parent():
         except Exception as e:
             val = get_variable_from_exception(e, 'parent_var')
 
-        self.assertEquals(val, 1)
+        self.assertEqual(val, 1)
 
     def test_get_variable_from_child(self):
         def child():
@@ -45,7 +45,7 @@ def parent():
         except Exception as e:
             val = get_variable_from_exception(e, 'child_var')
 
-        self.assertEquals(val, 2)
+        self.assertEqual(val, 2)
 
     def test_raise_key_error(self):
         def child():
@@ -72,7 +72,7 @@ def test_key_deletion(self):
 
         force_delete_key(self.address)
 
-        self.assertEquals(len(self.gpg.list_keys()), 0)
+        self.assertEqual(len(self.gpg.list_keys()), 0)
 
 
 class ForceMailAdminsTestCase(TestCase):

tests/integration/test_models.py

@@ -22,27 +22,27 @@ def test_key_model_functions(self):
         key.save()
 
         # Test Key.__str__()
-        self.assertEquals(str(key), TEST_KEY_FINGERPRINT)
+        self.assertEqual(str(key), TEST_KEY_FINGERPRINT)
 
         # Test Key.email_addresses property
-        self.assertEquals(key.email_addresses,
+        self.assertEqual(key.email_addresses,
                           'django-secure-mail@example.com')
 
         address = Address.objects.get(key=key)
 
         # Test Address.__str__()
-        self.assertEquals(str(address), 'django-secure-mail@example.com')
+        self.assertEqual(str(address), 'django-secure-mail@example.com')
 
-        self.assertEquals(address.address, 'django-secure-mail@example.com')
+        self.assertEqual(address.address, 'django-secure-mail@example.com')
 
         fp = key.fingerprint
-        self.assertEquals(fp, TEST_KEY_FINGERPRINT)
+        self.assertEqual(fp, TEST_KEY_FINGERPRINT)
 
         address.delete()
         key.delete()
 
-        self.assertEquals(Address.objects.count(), 0)
-        self.assertEquals(Key.objects.count(), 0)
+        self.assertEqual(Address.objects.count(), 0)
+        self.assertEqual(Key.objects.count(), 0)
 
     def test_address_delete_only_keys_matching_address(self):
         key = Key(key=TEST_PUBLIC_KEY, use_asc=False)
@@ -52,22 +52,22 @@ def test_address_delete_only_keys_matching_address(self):
         self.gpg.gen_key(self.gpg.gen_key_input(**SIGNING_KEY_DATA))
 
         # Test Key.__str__()
-        self.assertEquals(str(key), TEST_KEY_FINGERPRINT)
+        self.assertEqual(str(key), TEST_KEY_FINGERPRINT)
 
         # Test Key.email_addresses property
-        self.assertEquals(key.email_addresses,
+        self.assertEqual(key.email_addresses,
                           'django-secure-mail@example.com')
 
         address = Address.objects.get(key=key)
 
         address.delete()
         key.delete()
 
-        self.assertEquals(Address.objects.count(), 0)
-        self.assertEquals(Key.objects.count(), 0)
+        self.assertEqual(Address.objects.count(), 0)
+        self.assertEqual(Key.objects.count(), 0)
 
-        self.assertEquals(len(self.gpg.list_keys()), 1)
+        self.assertEqual(len(self.gpg.list_keys()), 1)
 
         self.delete_all_keys()
 
-        self.assertEquals(len(self.gpg.list_keys()), 0)
+        self.assertEqual(len(self.gpg.list_keys()), 0)

tests/unit/test_utils.py

@@ -12,7 +12,7 @@ def test_get_gpg_default_encoding(self):
             utils.GNUPG_ENCODING = previous_value
 
         # GPG.encoding is hard-coded to latin-1 in gnupg.py
-        self.assertEquals(gpg_obj.encoding, 'latin-1')
+        self.assertEqual(gpg_obj.encoding, 'latin-1')
 
     def test_get_gpg_specified_encoding(self):
         from secure_mail import utils
@@ -23,4 +23,4 @@ def test_get_gpg_specified_encoding(self):
         finally:
             utils.GNUPG_ENCODING = previous_value
 
-        self.assertEquals(gpg_obj.encoding, 'utf-8')
+        self.assertEqual(gpg_obj.encoding, 'utf-8')

tests/urls.py

@@ -13,9 +13,9 @@
     1. Import the include() function: from django.conf.urls import url, include
     2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
 """
-from django.conf.urls import url
+from django.urls import path
 from django.contrib import admin
 
 urlpatterns = [
-    url(r'^admin/', admin.site.urls),
+    path('admin/', admin.site.urls),
 ]