django-esi 5.2.0__py3-none-any.whl → 5.3.0b2__py3-none-any.whl

{django_esi-5.2.0.dist-info → django_esi-5.3.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-esi
-Version: 5.2.0
+Version: 5.3.0b2
 Summary: Django app for accessing the EVE Swagger Interface (ESI).
 Author-email: Alliance Auth <adarnof@gmail.com>
 Requires-Python: >=3.8

{django_esi-5.2.0.dist-info → django_esi-5.3.0b2.dist-info}/RECORD

@@ -1,12 +1,12 @@
-esi/__init__.py,sha256=5n3mCOnYm8mdzIJT1y6MQF6lBq9XxekR88WOIajAU_Q,155
+esi/__init__.py,sha256=cBiSUN_iSnPtTJYcRCW8FXS4dK6D92xNh5x_0FGmxRg,157
 esi/admin.py,sha256=vfpTW1WOLmAxQKAAW8d_Nrkn1MvVRO9raQrHGXpW2l4,1100
-esi/app_settings.py,sha256=1P1yELcXhTDabKHaqTTHUA6VOYRCKdA-3sKfObq7S9w,3788
+esi/app_settings.py,sha256=O8TkKonK2zdF7RjMem1vMhEMulAtjvksxKgchrI8jME,3783
 esi/apps.py,sha256=RXDeRh62DO8NcKEzpiQovOay9wmb7MoVyC1W-cc-Aqc,272
 esi/checks.py,sha256=o3ka-Ux3QqTaf0u-oFGCPxwuG7DNJ3XYXiC7_2rQ1Ic,1154
 esi/clients.py,sha256=gkkJVZ9xqcd0TOI-5VduqYLaave1LjI16ucckr3UX9o,21303
 esi/decorators.py,sha256=USqGaIrVoyMpKlUB_ddZPe7QK0fBrFqAnoZDj8MMlSI,8081
 esi/errors.py,sha256=KfFtgX8Mys4uMoQtco0n_pQeaM83yVrRSyW6StXuUjo,308
-esi/managers.py,sha256=JfsUhAxB7oI9msr-1TS9FklgsQfwLBjOKbBHVFTgdg4,11144
+esi/managers.py,sha256=0g3J2jgoX-BviisjDEEAypkTayVBY-G2I_ZuskTDUqg,11350
 esi/models.py,sha256=fJJu8rLDMGW3ChxwFAZtFBWKB7PgMuDBatTuT06gWiA,11412
 esi/tasks.py,sha256=6wOqlANbQ83uvOt0L4_QHaLz0YZe1jtrQyr7zmxKY6g,1516
 esi/urls.py,sha256=RV_ZirfB3oEElPGXfj33m6FqwVdFRADDW9bN1WwJU2E,161
@@ -61,7 +61,7 @@ esi/tests/test_checks.py,sha256=ntq2ijuJ-6pxGruNh21rM4GlXDLVm-o3sy8DrFbjwEM,1846
 esi/tests/test_clients.py,sha256=eaB0DniNrpaQiAQGokLMmcwWYq0H1iswz3fdKvuf3E4,36037
 esi/tests/test_decorators.py,sha256=I5MhcLKhN5xD4PxgEQqOWQ2kiXquDqQIEve9dbTOsho,15069
 esi/tests/test_management_command.py,sha256=mtxfBtG6CHP1bTy1tJEO-djX4SQwMT3T_mqGnUIM6qs,9863
-esi/tests/test_managers.py,sha256=V9KAnVnyXk2oHyy26aVm5FN5UTSG6Y63fU3FSGt7IHE,24548
+esi/tests/test_managers.py,sha256=CEpjXSXyVY6xxgrs0f9FnEh-KY9JPaKjKYiutXLLShE,24309
 esi/tests/test_models.py,sha256=lDj5IcYgXHeOFTHXTsWGg13CSooFaxD0c51kJn_ytAc,13748
 esi/tests/test_swagger.json,sha256=HOrPgbvwm5N521QNcE3baWcZJkSjmuN_VWrR06wEQoo,17241
 esi/tests/test_swagger_full.json,sha256=JCEAZNMFhkdZhquTx4lDhrqGgCrzzzlYU64HdbEv8E4,2548369
@@ -69,7 +69,7 @@ esi/tests/test_tasks.py,sha256=P3vtqSno92DywNYu38nIo-_UiSicRAbun1AAsav0EBo,2104
 esi/tests/test_templatetags.py,sha256=b68JWE3HvOlr2aUisJHsTsDS4e7IMjDeqTuzMqC7Re4,517
 esi/tests/test_views.py,sha256=Kj_f2yIpmPG0kx-lAX_sfkaHlIpgbkm02ieA1V3o-k4,13073
 esi/tests/threading_pilot.py,sha256=ax_dEdnTNibA-UQHqbZle_2dh_3jcHKRyrYSOKuE_6U,1931
-django_esi-5.2.0.dist-info/LICENSE,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
-django_esi-5.2.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-django_esi-5.2.0.dist-info/METADATA,sha256=F-hrJgyoZOKui9zpRMLkvxS7amvA3Db3jE5BN2L-Vvk,4273
-django_esi-5.2.0.dist-info/RECORD,,
+django_esi-5.3.0b2.dist-info/LICENSE,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
+django_esi-5.3.0b2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+django_esi-5.3.0b2.dist-info/METADATA,sha256=GyLdysYgGaYlQQN-nCZWYLeXGUlqHHoIY1vvhlmRSkY,4275
+django_esi-5.3.0b2.dist-info/RECORD,,

esi/__init__.py

@@ -2,5 +2,5 @@
 
 default_app_config = 'esi.apps.EsiConfig'
 
-__version__ = '5.2.0'
+__version__ = '5.3.0b2'
 __title__ = 'django-esi'

esi/app_settings.py

@@ -31,7 +31,7 @@ ESI_INFO_LOGGING_ENABLED = getattr(settings, 'ESI_INFO_LOGGING_ENABLED', False)
 ESI_LOG_LEVEL_LIBRARIES = str(getattr(settings, 'ESI_LOG_LEVEL_LIBRARIES', 'INFO'))
 """Set log level for libraries like bravado and urlib3."""
 
-ESI_DEBUG_RESPONSE_CONTENT_LOGGING = str(getattr(settings, 'ESI_DEBUG_RESPONSE_CONTENT_LOGGING', True))
+ESI_DEBUG_RESPONSE_CONTENT_LOGGING = getattr(settings, 'ESI_DEBUG_RESPONSE_CONTENT_LOGGING', True)
 """Enable/Disable logging of ESI response contents."""
 
 ESI_USER_CONTACT_EMAIL = getattr(settings, 'ESI_USER_CONTACT_EMAIL', None)

esi/managers.py

@@ -1,18 +1,16 @@
-from datetime import timedelta
 import logging
-from typing import Union, Any
+from datetime import timedelta
+from typing import Any, Union
 
 import requests
-from requests_oauthlib import OAuth2Session
-
 from django.db import models
 from django.utils import timezone
-
-from .errors import TokenError, IncompleteResponseError
-from . import app_settings
-
 from jose import jwt
 from jose.exceptions import ExpiredSignatureError, JWTError
+from requests_oauthlib import OAuth2Session
+
+from . import app_settings
+from .errors import IncompleteResponseError, TokenError
 
 logger = logging.getLogger(__name__)
 
@@ -75,10 +73,12 @@ class TokenQueryset(models.QuerySet):
         Returns:
             All tokens which are still valid.
         """
-        expired = self.get_expired()
-        valid = self.exclude(pk__in=expired)
-        valid_expired = expired.bulk_refresh()
-        return valid_expired | valid
+        expired_pks = set(self.get_expired().values_list("pk", flat=True))
+        fresh_pks = set(self.exclude(pk__in=expired_pks).values_list("pk", flat=True))
+        refreshed = self.filter(pk__in=expired_pks).bulk_refresh()
+        refreshed_pks = set(refreshed.values_list("pk", flat=True))
+        qs = self.filter(pk__in=fresh_pks | refreshed_pks)
+        return qs
 
     def require_scopes(self, scope_string: Union[str, list]) -> models.QuerySet:
         """Filter tokens which have at least a subset of given scopes.

esi/tests/test_managers.py

@@ -16,74 +16,49 @@ from .jwt_factory import generate_jwk, generate_token
 
 
 class TestProcessScopes(TestCase):
-
     def test_none(self):
-        self.assertSetEqual(
-            _process_scopes(None), set()
-        )
+        self.assertSetEqual(_process_scopes(None), set())
 
     def test_empty_list(self):
-        self.assertSetEqual(
-            _process_scopes([]), set()
-        )
+        self.assertSetEqual(_process_scopes([]), set())
 
     def test_single_string_1(self):
-        self.assertSetEqual(
-            _process_scopes(['one']),
-            {'one'}
-        )
+        self.assertSetEqual(_process_scopes(["one"]), {"one"})
 
     def test_single_string_2(self):
-        self.assertSetEqual(
-            _process_scopes(['one two three']),
-            {'one', 'two', 'three'}
-        )
+        self.assertSetEqual(_process_scopes(["one two three"]), {"one", "two", "three"})
 
     def test_list(self):
         self.assertSetEqual(
-            _process_scopes(['one', 'two', 'three']),
-            {'one', 'two', 'three'}
+            _process_scopes(["one", "two", "three"]), {"one", "two", "three"}
         )
 
     def test_tuple(self):
         self.assertSetEqual(
-            _process_scopes(('one', 'two', 'three')),
-            {'one', 'two', 'three'}
+            _process_scopes(("one", "two", "three")), {"one", "two", "three"}
         )
 
 
-class TestTokenQuerySet(TestCase):
-
-    def setUp(self):
+class TestTokenGetExpired(TestCase):
+    @patch("esi.models.app_settings.ESI_TOKEN_VALID_DURATION", 120)
+    def test_get_expired(self):
         self.user1 = User.objects.create_user(
-            'Bruce Wayne',
-            'abc@example.com',
-            'password'
+            "Bruce Wayne", "abc@example.com", "password"
         )
         self.user2 = User.objects.create_user(
-            'Peter Parker',
-            'abc@example.com',
-            'password'
+            "Peter Parker", "abc@example.com", "password"
         )
-        Token.objects.all().delete()
-
-    @patch('esi.models.app_settings.ESI_TOKEN_VALID_DURATION', 120)
-    def test_get_expired(self):
         _store_as_Token(
             _generate_token(
-                character_id=101,
-                character_name=self.user1.username,
-                scopes=['abc']
+                character_id=101, character_name=self.user1.username, scopes=["abc"]
             ),
-            self.user1
+            self.user1,
         )
         t2 = _store_as_Token(
             _generate_token(
-                character_id=102,
-                character_name=self.user2.username,
-                scopes=['xyz']
+                character_id=102, character_name=self.user2.username, scopes=["xyz"]
             ),
-            self.user2
+            self.user2,
         )
         self.assertEqual(list(Token.objects.get_queryset().get_expired()), [])
 
@@ -91,44 +66,46 @@ class TestTokenQuerySet(TestCase):
         t2.save()
         self.assertEqual(list(Token.objects.get_queryset().get_expired()), [t2])
 
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_ID', 'abc')
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_SECRET', 'xyz')
-    @patch('esi.models.Token.delete', autospec=True)
-    @patch('esi.models.Token.refresh', autospec=True)
-    @patch('esi.managers.requests.auth.HTTPBasicAuth', autospec=True)
-    @patch('esi.managers.OAuth2Session', autospec=True)
+
+@patch("esi.managers.app_settings.ESI_SSO_CLIENT_ID", "abc")
+@patch("esi.managers.app_settings.ESI_SSO_CLIENT_SECRET", "xyz")
+@patch("esi.models.Token.delete", autospec=True)
+@patch("esi.models.Token.refresh", autospec=True)
+@patch("esi.managers.requests.auth.HTTPBasicAuth", autospec=True)
+@patch("esi.managers.OAuth2Session", autospec=True)
+class TestTokenBulkRefresh(TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.user = User.objects.create_user(
+            "Bruce Wayne", "abc@example.com", "password"
+        )
+
     def test_bulk_refresh_normal(
         self,
         mock_OAuth2Session,
         mock_HTTPBasicAuth,
         mock_Token_refresh,
-        mock_Token_delete
+        mock_Token_delete,
     ):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         t1 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['abc']
+                character_id=character_id, character_name=character_name, scopes=["abc"]
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['xyz']
+                character_id=character_id, character_name=character_name, scopes=["xyz"]
             ),
-            self.user1
+            self.user,
         )
         incomplete_qs = Token.objects.get_queryset().bulk_refresh()
         self.assertEqual(mock_Token_refresh.call_count, 2)
         self.assertEqual(mock_Token_delete.call_count, 0)
-        self.assertSetEqual(
-            set(incomplete_qs),
-            {t1, t2}
-        )
+        self.assertSetEqual(set(incomplete_qs), {t1, t2})
 
         # Note
         # looks like a bug in bulk_refresh():
@@ -136,340 +113,337 @@ class TestTokenQuerySet(TestCase):
         # can not be null:
         #   self.filter(refresh_token__isnull=True).get_expired().delete()
 
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_ID', 'abc')
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_SECRET', 'xyz')
-    @patch('esi.models.Token.delete', autospec=True)
-    @patch('esi.models.Token.refresh', autospec=True)
-    @patch('esi.managers.requests.auth.HTTPBasicAuth', autospec=True)
-    @patch('esi.managers.OAuth2Session', autospec=True)
     def test_bulk_refresh_token_error(
         self,
         mock_OAuth2Session,
         mock_HTTPBasicAuth,
         mock_Token_refresh,
-        mock_Token_delete
+        mock_Token_delete,
     ):
         mock_Token_refresh.side_effect = TokenError
 
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         t1 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['abc']
+                character_id=character_id, character_name=character_name, scopes=["abc"]
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['xyz']
+                character_id=character_id, character_name=character_name, scopes=["xyz"]
             ),
-            self.user1
+            self.user,
         )
         incomplete_qs = Token.objects.get_queryset().bulk_refresh()
         self.assertEqual(mock_Token_refresh.call_count, 2)
         self.assertEqual(mock_Token_delete.call_count, 2)
-        self.assertSetEqual(
-            set(incomplete_qs),
-            {t1, t2}
-        )
+        self.assertSetEqual(set(incomplete_qs), {t1, t2})
 
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_ID', 'abc')
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_SECRET', 'xyz')
-    @patch('esi.models.Token.delete', autospec=True)
-    @patch('esi.models.Token.refresh', autospec=True)
-    @patch('esi.managers.requests.auth.HTTPBasicAuth', autospec=True)
-    @patch('esi.managers.OAuth2Session', autospec=True)
     def test_bulk_refresh_incomplete_response_error(
         self,
         mock_OAuth2Session,
         mock_HTTPBasicAuth,
         mock_Token_refresh,
-        mock_Token_delete
+        mock_Token_delete,
     ):
         mock_Token_refresh.side_effect = IncompleteResponseError
 
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['abc']
+                character_id=character_id, character_name=character_name, scopes=["abc"]
             ),
-            self.user1
+            self.user,
         )
         _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['xyz']
+                character_id=character_id, character_name=character_name, scopes=["xyz"]
             ),
-            self.user1
+            self.user,
         )
         incomplete_qs = Token.objects.get_queryset().bulk_refresh()
         self.assertEqual(mock_Token_refresh.call_count, 2)
         self.assertEqual(mock_Token_delete.call_count, 0)
-        self.assertSetEqual(
-            set(incomplete_qs),
-            set()
+        self.assertSetEqual(set(incomplete_qs), set())
+
+
+@patch("esi.models.app_settings.ESI_TOKEN_VALID_DURATION", 120)
+@patch("esi.managers.TokenQueryset.bulk_refresh", autospec=True)
+class TestTokenRequireValid(TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.user = User.objects.create_user(
+            "Bruce Wayne", "abc@example.com", "password"
         )
 
-    @patch('esi.models.app_settings.ESI_TOKEN_VALID_DURATION', 120)
-    @patch('esi.managers.TokenQueryset.bulk_refresh', autospec=True)
-    def test_require_valid_none_expired(
-        self,
-        mock_bulk_refresh
-    ):
+    def test_require_valid_none_expired(self, mock_bulk_refresh):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         t1 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['abc']
+                character_id=character_id, character_name=character_name, scopes=["abc"]
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['xyz']
+                character_id=character_id, character_name=character_name, scopes=["xyz"]
             ),
-            self.user1
+            self.user,
         )
         mock_bulk_refresh.return_value = Token.objects.none()
 
-        self.assertSetEqual(
-            set(Token.objects.get_queryset().require_valid()),
-            {t1, t2}
-        )
+        self.assertSetEqual(set(Token.objects.get_queryset().require_valid()), {t1, t2})
 
-    @patch('esi.models.app_settings.ESI_TOKEN_VALID_DURATION', 120)
-    @patch('esi.managers.TokenQueryset.bulk_refresh', autospec=True)
-    def test_require_valid_some_expired(
-        self,
-        mock_bulk_refresh
-    ):
+    def test_require_valid_some_expired(self, mock_bulk_refresh):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         t1 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['abc']
+                character_id=character_id, character_name=character_name, scopes=["abc"]
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['xyz']
+                character_id=character_id, character_name=character_name, scopes=["xyz"]
             ),
-            self.user1
+            self.user,
         )
         t2.created -= timedelta(121)
         t2.save()
         mock_bulk_refresh.return_value = Token.objects.filter(pk__in=[t2.pk])
 
-        self.assertSetEqual(
-            set(Token.objects.get_queryset().require_valid()),
-            {t1, t2}
-        )
+        self.assertSetEqual(set(Token.objects.get_queryset().require_valid()), {t1, t2})
 
-    @patch('esi.models.app_settings.ESI_TOKEN_VALID_DURATION', 120)
-    @patch('esi.managers.TokenQueryset.bulk_refresh', autospec=True)
-    def test_require_valid_one_refresh_error(
-        self,
-        mock_bulk_refresh
-    ):
+    def test_require_valid_one_refresh_error(self, mock_bulk_refresh):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         t1 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['abc']
+                character_id=character_id, character_name=character_name, scopes=["abc"]
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
-                character_id=character_id,
-                character_name=character_name,
-                scopes=['xyz']
+                character_id=character_id, character_name=character_name, scopes=["xyz"]
             ),
-            self.user1
+            self.user,
         )
         t2.created -= timedelta(121)
         t2.save()
         mock_bulk_refresh.return_value = Token.objects.none()
 
-        self.assertSetEqual(
-            set(Token.objects.get_queryset().require_valid()),
-            {t1}
+        self.assertSetEqual(set(Token.objects.get_queryset().require_valid()), {t1})
+
+
+@patch("esi.models.app_settings.ESI_TOKEN_VALID_DURATION", 120)
+@patch("esi.models.Token.refresh", spec=True)
+class TestTokenBulkRefreshXRequireValid(TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.user = User.objects.create_user(
+            "Bruce Wayne", "abc@example.com", "password"
+        )
+
+    def test_require_valid_all_expired(self, mock_token_refresh):
+        """Test demonstrates the bug introduced with 5.3.0b1.
+
+        bulk_refresh() does not return the token after it has been refreshed.
+        Then also require_valid() does not return the refreshed token.
+        Apps calling require_valid() will then assume there is no valid token.
+        The previous tests did not catch this bug, because it they were testing
+        the methods one by one and mocking out responses from other methods.
+        """
+        def my_refresh(*args, **kwargs):
+            t.created = now()
+            t.save()
+
+        # given
+        mock_token_refresh.side_effect = my_refresh
+        character_id = 99
+        character_name = "Bruce Wayne"
+        t: Token = _store_as_Token(
+            _generate_token(
+                character_id=character_id, character_name=character_name, scopes=["abc"]
+            ),
+            self.user,
+        )
+        t.created -= timedelta(121)
+        t.save()
+
+        # when
+        qs = Token.objects.get_queryset().require_valid()
+
+        # then
+        expected = set(qs.values_list("pk", flat=True))
+        self.assertSetEqual(expected, {t.pk})
+
+
+class TestTokenRequireScopes(TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.user = User.objects.create_user(
+            "Bruce Wayne", "abc@example.com", "password"
         )
 
     def test_require_scopes_normal(self):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         t1 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz', '123']
+                scopes=["abc", "xyz", "123"],
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz']
+                scopes=["abc", "xyz"],
             ),
-            self.user1
+            self.user,
         )
         t3 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', '123']
+                scopes=["abc", "123"],
             ),
-            self.user1
+            self.user,
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes('abc')), {t1, t2, t3}
+            set(Token.objects.get_queryset().require_scopes("abc")), {t1, t2, t3}
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes('xyz')), {t1, t2}
+            set(Token.objects.get_queryset().require_scopes("xyz")), {t1, t2}
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes('123')), {t1, t3}
+            set(Token.objects.get_queryset().require_scopes("123")), {t1, t3}
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes('555')), set()
+            set(Token.objects.get_queryset().require_scopes("555")), set()
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes('abc xyz 123')), {t1}
+            set(Token.objects.get_queryset().require_scopes("abc xyz 123")), {t1}
         )
 
     def test_require_scopes_empty(self):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz', '123']
+                scopes=["abc", "xyz", "123"],
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
-            _generate_token(
-                character_id=character_id,
-                character_name=character_name
-            ),
-            self.user1
+            _generate_token(character_id=character_id, character_name=character_name),
+            self.user,
         )
         t2.scopes.all().delete()
         _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', '123']
+                scopes=["abc", "123"],
             ),
-            self.user1
+            self.user,
         )
-        self.assertSetEqual(set(Token.objects.get_queryset().require_scopes('')), {t2})
+        self.assertSetEqual(set(Token.objects.get_queryset().require_scopes("")), {t2})
 
     def test_require_scopes_exact(self):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz', '123']
+                scopes=["abc", "xyz", "123"],
             ),
-            self.user1
+            self.user,
         )
         t2 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz']
+                scopes=["abc", "xyz"],
             ),
-            self.user1
+            self.user,
         )
         t3 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', '123']
+                scopes=["abc", "123"],
             ),
-            self.user1
+            self.user,
         )
         t4 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', '123']
+                scopes=["abc", "123"],
             ),
-            self.user1
+            self.user,
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes_exact('abc')), set()
+            set(Token.objects.get_queryset().require_scopes_exact("abc")), set()
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes_exact('abc xyz')), {t2}
+            set(Token.objects.get_queryset().require_scopes_exact("abc xyz")), {t2}
         )
         self.assertSetEqual(
-            set(Token.objects.get_queryset().require_scopes_exact('abc 123')), {t3, t4}
+            set(Token.objects.get_queryset().require_scopes_exact("abc 123")), {t3, t4}
         )
 
     def test_require_scopes_exact_2(self):
         character_id = 99
-        character_name = 'Bruce Wayne'
+        character_name = "Bruce Wayne"
         _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz', '123']
+                scopes=["abc", "xyz", "123"],
             ),
-            self.user1
+            self.user,
         )
         _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['abc', 'xyz']
+                scopes=["abc", "xyz"],
             ),
-            self.user1
+            self.user,
         )
         t3 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['xyz', '123']
+                scopes=["xyz", "123"],
             ),
-            self.user1
+            self.user,
         )
         t4 = _store_as_Token(
             _generate_token(
                 character_id=character_id,
                 character_name=character_name,
-                scopes=['xyz', '123']
+                scopes=["xyz", "123"],
             ),
-            self.user1
-        )
-        self.assertSetEqual(
-            set(Token.objects.get_queryset().equivalent_to(t3)), {t4}
+            self.user,
         )
+        self.assertSetEqual(set(Token.objects.get_queryset().equivalent_to(t3)), {t4})
 
 
 class TestTokenManager(TestCase):
@@ -478,173 +452,146 @@ class TestTokenManager(TestCase):
         self.factory = RequestFactory()
 
         self.user1 = User.objects.create_user(
-            'Bruce Wayne',
-            'abc@example.com',
-            'password'
-        )
-
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_ID', 'abc')
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_SECRET', 'xyz')
-    @patch('esi.managers.app_settings.ESI_SSO_CALLBACK_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_TOKEN_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_TOKEN_VERIFY_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_ALWAYS_CREATE_TOKEN', False)
-    @patch('esi.managers.TokenManager._decode_jwt')
-    @patch('esi.managers.OAuth2Session', autospec=True)
+            "Bruce Wayne", "abc@example.com", "password"
+        )
+
+    @patch("esi.managers.app_settings.ESI_SSO_CLIENT_ID", "abc")
+    @patch("esi.managers.app_settings.ESI_SSO_CLIENT_SECRET", "xyz")
+    @patch("esi.managers.app_settings.ESI_SSO_CALLBACK_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_TOKEN_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_TOKEN_VERIFY_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_ALWAYS_CREATE_TOKEN", False)
+    @patch("esi.managers.TokenManager._decode_jwt")
+    @patch("esi.managers.OAuth2Session", autospec=True)
     def test_create_from_code_single_scope(self, mock_OAuth2Session, mock_decode_jwt):
         """Normal case with refresh token"""
         mock_oauth = Mock()
-        mock_oauth.request.return_value.json.return_value = \
-            _generate_token(
-                99, 'Bruce Wayne', scopes='publicData'
-            )
+        mock_oauth.request.return_value.json.return_value = _generate_token(
+            99, "Bruce Wayne", scopes="publicData"
+        )
         mock_oauth.fetch_token.return_value = {
-            'access_token': 'access_token',
-            'refresh_token': 'refresh_token',
-            'token_type': 'Bearer',
-            'expires_in': 1200,
+            "access_token": "access_token",
+            "refresh_token": "refresh_token",
+            "token_type": "Bearer",
+            "expires_in": 1200,
         }
         mock_OAuth2Session.return_value = mock_oauth
-        mock_decode_jwt.return_value = \
-            _generate_token(
-                99, 'Bruce Wayne', scopes='publicData'
-            )
-        # create new token from code
-        token1 = Token.objects.create_from_code('abc123xyz')
-        self.assertEqual(
-            token1.character_id,
-            99
-        )
-        self.assertEqual(
-            token1.character_name,
-            'Bruce Wayne'
-        )
-        self.assertEqual(
-            token1.scopes.all().count(),
-            1
+        mock_decode_jwt.return_value = _generate_token(
+            99, "Bruce Wayne", scopes="publicData"
         )
+        # create new token from code
+        token1 = Token.objects.create_from_code("abc123xyz")
+        self.assertEqual(token1.character_id, 99)
+        self.assertEqual(token1.character_name, "Bruce Wayne")
+        self.assertEqual(token1.scopes.all().count(), 1)
         # should return existing token instead of creating a new one
         # since ESI_ALWAYS_CREATE_TOKEN is False
-        token2 = Token.objects.create_from_code('11abc123xyz')
+        token2 = Token.objects.create_from_code("11abc123xyz")
         self.assertEqual(token1, token2)
 
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_ID', 'abc')
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_SECRET', 'xyz')
-    @patch('esi.managers.app_settings.ESI_SSO_CALLBACK_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_TOKEN_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_TOKEN_VERIFY_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_ALWAYS_CREATE_TOKEN', False)
-    @patch('esi.managers.TokenManager._decode_jwt')
-    @patch('esi.managers.OAuth2Session', autospec=True)
+    @patch("esi.managers.app_settings.ESI_SSO_CLIENT_ID", "abc")
+    @patch("esi.managers.app_settings.ESI_SSO_CLIENT_SECRET", "xyz")
+    @patch("esi.managers.app_settings.ESI_SSO_CALLBACK_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_TOKEN_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_TOKEN_VERIFY_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_ALWAYS_CREATE_TOKEN", False)
+    @patch("esi.managers.TokenManager._decode_jwt")
+    @patch("esi.managers.OAuth2Session", autospec=True)
     def test_create_from_code_1(self, mock_OAuth2Session, mock_decode_jwt):
         """Normal case with refresh token"""
         mock_oauth = Mock()
-        mock_oauth.request.return_value.json.return_value = \
-            _generate_token(
-                99, 'Bruce Wayne', scopes=[
-                    'esi-calendar.read_calendar_events.v1',
-                    'esi-location.read_location.v1',
-                    'esi-location.read_ship_type.v1',
-                    'esi-unknown-scope'
-                ]
-            )
+        mock_oauth.request.return_value.json.return_value = _generate_token(
+            99,
+            "Bruce Wayne",
+            scopes=[
+                "esi-calendar.read_calendar_events.v1",
+                "esi-location.read_location.v1",
+                "esi-location.read_ship_type.v1",
+                "esi-unknown-scope",
+            ],
+        )
         mock_oauth.fetch_token.return_value = {
-            'access_token': 'access_token',
-            'refresh_token': 'refresh_token',
-            'token_type': 'Bearer',
-            'expires_in': 1200,
+            "access_token": "access_token",
+            "refresh_token": "refresh_token",
+            "token_type": "Bearer",
+            "expires_in": 1200,
         }
         mock_OAuth2Session.return_value = mock_oauth
-        mock_decode_jwt.return_value = \
-            _generate_token(
-                99, 'Bruce Wayne', scopes=[
-                    'esi-calendar.read_calendar_events.v1',
-                    'esi-location.read_location.v1',
-                    'esi-location.read_ship_type.v1',
-                    'esi-unknown-scope'
-                ]
-            )
-        # create new token from code
-        token1 = Token.objects.create_from_code('abc123xyz')
-        self.assertEqual(
-            token1.character_id,
-            99
-        )
-        self.assertEqual(
-            token1.character_name,
-            'Bruce Wayne'
-        )
-        self.assertEqual(
-            token1.scopes.all().count(),
-            4
+        mock_decode_jwt.return_value = _generate_token(
+            99,
+            "Bruce Wayne",
+            scopes=[
+                "esi-calendar.read_calendar_events.v1",
+                "esi-location.read_location.v1",
+                "esi-location.read_ship_type.v1",
+                "esi-unknown-scope",
+            ],
         )
+        # create new token from code
+        token1 = Token.objects.create_from_code("abc123xyz")
+        self.assertEqual(token1.character_id, 99)
+        self.assertEqual(token1.character_name, "Bruce Wayne")
+        self.assertEqual(token1.scopes.all().count(), 4)
 
         # should return existing token instead of creating a new one
         # since ESI_ALWAYS_CREATE_TOKEN is False
-        token2 = Token.objects.create_from_code('11abc123xyz')
+        token2 = Token.objects.create_from_code("11abc123xyz")
         self.assertEqual(token1, token2)
 
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_ID', 'abc')
-    @patch('esi.managers.app_settings.ESI_SSO_CLIENT_SECRET', 'xyz')
-    @patch('esi.managers.app_settings.ESI_SSO_CALLBACK_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_TOKEN_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_TOKEN_VERIFY_URL', 'localhost')
-    @patch('esi.managers.app_settings.ESI_ALWAYS_CREATE_TOKEN', False)
-    @patch('esi.managers.TokenManager._decode_jwt')
-    @patch('esi.managers.OAuth2Session', autospec=True)
+    @patch("esi.managers.app_settings.ESI_SSO_CLIENT_ID", "abc")
+    @patch("esi.managers.app_settings.ESI_SSO_CLIENT_SECRET", "xyz")
+    @patch("esi.managers.app_settings.ESI_SSO_CALLBACK_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_TOKEN_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_TOKEN_VERIFY_URL", "localhost")
+    @patch("esi.managers.app_settings.ESI_ALWAYS_CREATE_TOKEN", False)
+    @patch("esi.managers.TokenManager._decode_jwt")
+    @patch("esi.managers.OAuth2Session", autospec=True)
     def test_create_from_code_2(self, mock_OAuth2Session, mock_decode_jwt):
         """Special case w/o refresh token"""
         mock_oauth = Mock()
-        mock_oauth.request.return_value.json.return_value = \
-            _generate_token(
-                99, 'Bruce Wayne', scopes=[
-                    'esi-calendar.read_calendar_events.v1',
-                    'esi-location.read_location.v1',
-                    'esi-location.read_ship_type.v1',
-                    'esi-unknown-scope'
-                ]
-            )
+        mock_oauth.request.return_value.json.return_value = _generate_token(
+            99,
+            "Bruce Wayne",
+            scopes=[
+                "esi-calendar.read_calendar_events.v1",
+                "esi-location.read_location.v1",
+                "esi-location.read_ship_type.v1",
+                "esi-unknown-scope",
+            ],
+        )
         mock_oauth.fetch_token.return_value = {
-            'access_token': 'access_token',
-            'refresh_token': None,
-            'token_type': 'Bearer',
-            'expires_in': 1200,
+            "access_token": "access_token",
+            "refresh_token": None,
+            "token_type": "Bearer",
+            "expires_in": 1200,
         }
         mock_OAuth2Session.return_value = mock_oauth
-        mock_decode_jwt.return_value = \
-            _generate_token(
-                99, 'Bruce Wayne', scopes=[
-                    'esi-calendar.read_calendar_events.v1',
-                    'esi-location.read_location.v1',
-                    'esi-location.read_ship_type.v1',
-                    'esi-unknown-scope'
-                ]
-            )
-        # create new token from code
-        token1 = Token.objects.create_from_code('abc123xyz')
-        self.assertEqual(
-            token1.character_id,
-            99
-        )
-        self.assertEqual(
-            token1.character_name,
-            'Bruce Wayne'
-        )
-        self.assertEqual(
-            token1.scopes.all().count(),
-            4
+        mock_decode_jwt.return_value = _generate_token(
+            99,
+            "Bruce Wayne",
+            scopes=[
+                "esi-calendar.read_calendar_events.v1",
+                "esi-location.read_location.v1",
+                "esi-location.read_ship_type.v1",
+                "esi-unknown-scope",
+            ],
         )
+        # create new token from code
+        token1 = Token.objects.create_from_code("abc123xyz")
+        self.assertEqual(token1.character_id, 99)
+        self.assertEqual(token1.character_name, "Bruce Wayne")
+        self.assertEqual(token1.scopes.all().count(), 4)
 
         # should return existing token instead of creating a new one
         # since ESI_ALWAYS_CREATE_TOKEN is False
-        token2 = Token.objects.create_from_code('11abc123xyz')
+        token2 = Token.objects.create_from_code("11abc123xyz")
         self.assertEqual(token1, token2)
 
-    @patch('esi.managers.TokenManager.create_from_code', autospec=True)
+    @patch("esi.managers.TokenManager.create_from_code", autospec=True)
     def test_create_from_request(self, mock_create_from_code):
-        mock_create_from_code.return_value = 'we got you'
+        mock_create_from_code.return_value = "we got you"
 
-        request = self.factory.get('https://www.example.com?code=abc123')
+        request = self.factory.get("https://www.example.com?code=abc123")
         request.user = self.user1
 
         middleware = SessionMiddleware(HttpResponse)
@@ -652,8 +599,8 @@ class TestTokenManager(TestCase):
         request.session.save()
 
         x = Token.objects.create_from_request(request)
-        self.assertEqual(x, 'we got you')
-        self.assertEqual(mock_create_from_code.call_args[0][1], 'abc123')
+        self.assertEqual(x, "we got you")
+        self.assertEqual(mock_create_from_code.call_args[0][1], "abc123")
 
 
 @requests_mock.Mocker()