django-spire 0.23.6__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/auth/mfa/tests/test_models.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from dateutil import relativedelta
+from django.utils.timezone import localtime
+
+from django_spire.auth.mfa.models import MfaCode
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class MfaCodeModelTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser')
+
+    def test_generate_code_creates_valid_code(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        code_value = int(mfa_code.code)
+        assert mfa_code.user == self.user
+        assert 0 <= code_value <= 999999
+
+    def test_generate_code_sets_expiration(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert mfa_code.expiration_datetime > localtime()
+
+    def test_generate_code_expiration_is_five_minutes(self) -> None:
+        before = localtime()
+        mfa_code = MfaCode.generate_code(self.user)
+        after = localtime()
+        expected_min = before + relativedelta.relativedelta(minutes=5)
+        expected_max = after + relativedelta.relativedelta(minutes=5, seconds=1)
+        assert mfa_code.expiration_datetime >= expected_min
+        assert mfa_code.expiration_datetime <= expected_max
+
+    def test_is_valid_returns_true_for_unexpired(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert mfa_code.is_valid()
+
+    def test_is_valid_returns_false_for_expired(self) -> None:
+        mfa_code = MfaCode.objects.create(
+            user=self.user,
+            code='123456',
+            expiration_datetime=localtime() - relativedelta.relativedelta(minutes=1)
+        )
+        assert not mfa_code.is_valid()
+
+    def test_is_valid_boundary_expired(self) -> None:
+        mfa_code = MfaCode.objects.create(
+            user=self.user,
+            code='123456',
+            expiration_datetime=localtime() - relativedelta.relativedelta(seconds=1)
+        )
+        assert not mfa_code.is_valid()
+
+    def test_set_expired(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert mfa_code.is_valid()
+        mfa_code.set_expired()
+        assert not mfa_code.is_valid()
+
+    def test_set_expired_persists(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        mfa_code.set_expired()
+        mfa_code.refresh_from_db()
+        assert not mfa_code.is_valid()
+
+    def test_str_representation(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        expected = f'{mfa_code.expiration_datetime} - {mfa_code.code}'
+        assert str(mfa_code) == expected
+
+    def test_code_is_valid_numeric(self) -> None:
+        for _ in range(10):
+            mfa_code = MfaCode.generate_code(self.user)
+            code_value = int(mfa_code.code)
+            assert 0 <= code_value <= 999999
+            mfa_code.delete()
+
+    def test_multiple_codes_for_same_user(self) -> None:
+        code1 = MfaCode.generate_code(self.user)
+        code1.set_expired()
+        code2 = MfaCode.generate_code(self.user)
+        assert code1.pk != code2.pk
+
+    def test_codes_for_different_users(self) -> None:
+        user2 = create_user(username='testuser2')
+        code1 = MfaCode.generate_code(self.user)
+        code2 = MfaCode.generate_code(user2)
+        assert code1.user != code2.user
+
+    def test_code_user_relationship(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert mfa_code.user.pk == self.user.pk
+
+    def test_code_deletion_with_user(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        code_pk = mfa_code.pk
+        self.user.delete()
+        assert not MfaCode.objects.filter(pk=code_pk).exists()
+
+    def test_meta_db_table(self) -> None:
+        assert MfaCode._meta.db_table == 'django_spire_authentication_mfa_code'
+
+    def test_meta_verbose_name(self) -> None:
+        assert MfaCode._meta.verbose_name == 'MFA Code'
+        assert MfaCode._meta.verbose_name_plural == 'MFA Codes'
+
+    def test_code_length_is_six(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert len(str(mfa_code.code)) <= 6
+        assert int(mfa_code.code) <= 999999
+
+    def test_code_is_string(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert isinstance(mfa_code.code, (str, int))
+
+    def test_code_field_max_length(self) -> None:
+        max_length = MfaCode._meta.get_field('code').max_length
+        assert max_length == 6
+
+    def test_code_field_is_unique(self) -> None:
+        assert MfaCode._meta.get_field('code').unique
+
+    def test_code_field_is_not_editable(self) -> None:
+        assert not MfaCode._meta.get_field('code').editable
+
+    def test_expiration_field_is_not_editable(self) -> None:
+        assert not MfaCode._meta.get_field('expiration_datetime').editable
+
+    def test_user_foreign_key(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert mfa_code.user_id == self.user.pk
+
+    def test_user_related_name(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        assert mfa_code in self.user.mfa_codes.all()
+
+    def test_generate_code_creates_unique_codes(self) -> None:
+        codes = set()
+        for _ in range(100):
+            mfa_code = MfaCode.generate_code(self.user)
+            codes.add(mfa_code.code)
+            mfa_code.delete()
+        assert len(codes) > 90
+
+    def test_is_valid_exact_expiration_time(self) -> None:
+        mfa_code = MfaCode.objects.create(
+            user=self.user,
+            code='654321',
+            expiration_datetime=localtime()
+        )
+        assert not mfa_code.is_valid()
+
+    def test_code_with_leading_zeros(self) -> None:
+        mfa_code = MfaCode.objects.create(
+            user=self.user,
+            code='000123',
+            expiration_datetime=localtime() + relativedelta.relativedelta(minutes=5)
+        )
+        assert mfa_code.code == '000123'
+        assert len(mfa_code.code) == 6
+
+
+class MfaCodeQuerySetTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser')
+
+    def test_valid_code_returns_unexpired(self) -> None:
+        mfa_code = MfaCode.generate_code(self.user)
+        result = MfaCode.objects.valid_code(self.user)
+        assert result == mfa_code
+
+    def test_valid_code_returns_none_for_expired(self) -> None:
+        MfaCode.objects.create(
+            user=self.user,
+            code='123456',
+            expiration_datetime=localtime() - relativedelta.relativedelta(minutes=1)
+        )
+        result = MfaCode.objects.valid_code(self.user)
+        assert result is None
+
+    def test_valid_code_returns_none_for_different_user(self) -> None:
+        other_user = create_user(username='otheruser')
+        MfaCode.generate_code(other_user)
+        result = MfaCode.objects.valid_code(self.user)
+        assert result is None
+
+    def test_valid_code_returns_none_when_no_codes(self) -> None:
+        result = MfaCode.objects.valid_code(self.user)
+        assert result is None
+
+    def test_valid_code_returns_first_valid(self) -> None:
+        MfaCode.objects.create(
+            user=self.user,
+            code='111111',
+            expiration_datetime=localtime() - relativedelta.relativedelta(minutes=1)
+        )
+        valid_code = MfaCode.generate_code(self.user)
+        result = MfaCode.objects.valid_code(self.user)
+        assert result == valid_code
+
+    def test_valid_code_with_multiple_users(self) -> None:
+        user2 = create_user(username='testuser2')
+        code1 = MfaCode.generate_code(self.user)
+        MfaCode.generate_code(user2)
+        result = MfaCode.objects.valid_code(self.user)
+        assert result == code1
+
+    def test_valid_code_ignores_other_users_codes(self) -> None:
+        user2 = create_user(username='testuser2')
+        MfaCode.generate_code(user2)
+        result = MfaCode.objects.valid_code(self.user)
+        assert result is None
+
+    def test_valid_code_after_expiring_previous(self) -> None:
+        code1 = MfaCode.generate_code(self.user)
+        code1.set_expired()
+        code2 = MfaCode.generate_code(self.user)
+        result = MfaCode.objects.valid_code(self.user)
+        assert result == code2
+
+    def test_valid_code_multiple_valid_returns_first(self) -> None:
+        code1 = MfaCode.generate_code(self.user)
+        MfaCode.objects.create(
+            user=self.user,
+            code='999999',
+            expiration_datetime=localtime() + relativedelta.relativedelta(minutes=10)
+        )
+        result = MfaCode.objects.valid_code(self.user)
+        assert result == code1

django_spire/auth/mfa/tests/test_utils.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from django_spire.auth.mfa.models import MfaCode
+from django_spire.auth.mfa.utils import get_or_generate_user_mfa_code
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class GetOrGenerateUserMfaCodeTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser')
+
+    def test_generates_new_code_when_none_exists(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert mfa_code is not None
+        assert mfa_code.user == self.user
+        assert mfa_code.is_valid()
+
+    def test_returns_existing_valid_code(self) -> None:
+        existing_code = MfaCode.generate_code(self.user)
+        result = get_or_generate_user_mfa_code(self.user)
+        assert result.pk == existing_code.pk
+
+    def test_generates_new_code_when_existing_expired(self) -> None:
+        existing_code = MfaCode.generate_code(self.user)
+        existing_code.set_expired()
+
+        new_code = get_or_generate_user_mfa_code(self.user)
+        assert new_code.pk != existing_code.pk
+        assert new_code.is_valid()
+
+    def test_returns_same_code_on_multiple_calls(self) -> None:
+        code1 = get_or_generate_user_mfa_code(self.user)
+        code2 = get_or_generate_user_mfa_code(self.user)
+        assert code1.pk == code2.pk
+
+    def test_different_users_get_different_codes(self) -> None:
+        user2 = create_user(username='testuser2')
+        code1 = get_or_generate_user_mfa_code(self.user)
+        code2 = get_or_generate_user_mfa_code(user2)
+        assert code1.pk != code2.pk
+        assert code1.user != code2.user
+
+    def test_generated_code_is_persisted(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert MfaCode.objects.filter(pk=mfa_code.pk).exists()
+
+    def test_generates_valid_code_after_expiration(self) -> None:
+        code1 = get_or_generate_user_mfa_code(self.user)
+        code1.set_expired()
+        code2 = get_or_generate_user_mfa_code(self.user)
+        assert code2.is_valid()
+
+    def test_code_belongs_to_correct_user(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert mfa_code.user.pk == self.user.pk
+        assert mfa_code.user.username == self.user.username
+
+    def test_returns_mfa_code_instance(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert isinstance(mfa_code, MfaCode)
+
+    def test_code_has_valid_expiration(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert mfa_code.expiration_datetime is not None
+
+    def test_code_has_six_digits(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert len(str(mfa_code.code)) <= 6
+        assert int(mfa_code.code) <= 999999
+
+    def test_code_is_numeric(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert str(mfa_code.code).isdigit()
+
+    def test_multiple_expired_codes_generates_new(self) -> None:
+        code1 = get_or_generate_user_mfa_code(self.user)
+        code1.set_expired()
+        code2 = get_or_generate_user_mfa_code(self.user)
+        code2.set_expired()
+        code3 = get_or_generate_user_mfa_code(self.user)
+        assert code3.is_valid()
+        assert code3.pk != code1.pk
+        assert code3.pk != code2.pk
+
+    def test_does_not_affect_other_users_codes(self) -> None:
+        user2 = create_user(username='testuser2')
+        code1 = get_or_generate_user_mfa_code(self.user)
+        code2 = get_or_generate_user_mfa_code(user2)
+        code1.set_expired()
+        result = get_or_generate_user_mfa_code(user2)
+        assert result.pk == code2.pk
+
+    def test_new_code_after_delete(self) -> None:
+        code1 = get_or_generate_user_mfa_code(self.user)
+        code1_pk = code1.pk
+        code1.delete()
+        code2 = get_or_generate_user_mfa_code(self.user)
+        assert code2.pk != code1_pk
+
+    def test_code_user_relationship_intact(self) -> None:
+        mfa_code = get_or_generate_user_mfa_code(self.user)
+        assert mfa_code.user == self.user
+        assert mfa_code in self.user.mfa_codes.all()

django_spire/auth/mfa/urls/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import include, path
 
 

django_spire/auth/mfa/urls/page_urls.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from django_spire.auth.mfa.views import page_views

django_spire/auth/mfa/urls/redirect_urls.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from django_spire.auth.mfa.views import redirect_views

django_spire/auth/mfa/views/page_views.py

@@ -5,8 +5,8 @@ from django.http import HttpResponseRedirect
 from django.template.response import TemplateResponse
 from django.urls import reverse
 
-from django_spire.auth.mfa.utils import get_or_generate_user_mfa_code
 from django_spire.auth.mfa import forms
+from django_spire.auth.mfa.utils import get_or_generate_user_mfa_code
 
 
 def mfa_form_view(request):
@@ -15,6 +15,7 @@ def mfa_form_view(request):
 
     if request.method == 'POST':
         form = forms.MFAForm(mfa_code, request.POST)
+
         if form.is_valid():
             mfa_code.set_expired()
             profile.set_mfa_grace_period()

django_spire/auth/permissions/consts.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import Literal
 
-from django_spire.auth.group.models import AuthGroup
-from django_spire.auth.user.models import AuthUser
+# from django_spire.auth.group.models import AuthGroup
+# from django_spire.auth.user.models import AuthUser
 
 
 PERMISSIONS_LEVEL_CHOICES = (

django_spire/auth/permissions/decorators.py

@@ -13,12 +13,12 @@ if TYPE_CHECKING:
 
 
 def permission_required_decorator_function(
-        permissions: str | Sequence[str],
-        method,
-        request: WSGIRequest,
-        *args,
-        all_required: bool = True,
-        **kwargs
+    permissions: str | Sequence[str],
+    method,
+    request: WSGIRequest,
+    *args,
+    all_required: bool = True,
+    **kwargs
 ):
     if not request.user.is_authenticated:
         return HttpResponseRedirect(reverse('django_spire:auth:admin:login'))
@@ -40,8 +40,8 @@ def permission_required_decorator_function(
 
 
 def permission_required(
-        *permissions: str,
-        all_required: bool = True
+    *permissions: str,
+    all_required: bool = True
 ):
     def decorator(method):
         @functools.wraps(method)

django_spire/auth/permissions/permissions.py

@@ -10,20 +10,21 @@ from django_spire.auth.group.utils import (
     codename_to_perm_level,
     perm_level_to_string
 )
-from django_spire.auth.permissions.consts import VALID_PERMISSION_LEVELS
 from django_spire.core.utils import get_object_from_module_string
 
 if TYPE_CHECKING:
-    from django.db.models import QuerySet, Model
+    from django.db.models import Model, QuerySet
+
+    from django_spire.auth.permissions.consts import VALID_PERMISSION_LEVELS
 
 
 class ModelPermission:
     def __init__(
-            self,
-            name: str,
-            model_class_path: str,
-            is_proxy_model: bool,
-            verbose_name: str | None = None,
+        self,
+        name: str,
+        model_class_path: str,
+        is_proxy_model: bool,
+        verbose_name: str | None = None
     ):
         self.name = name
         self.model_class_path = model_class_path
@@ -57,13 +58,11 @@ class ModelPermissions:
         self,
         perm_level: VALID_PERMISSION_LEVELS | None
     ) -> list[Permission]:
-        permission_list = []
-
-        for perm in self.permissions:
-            if codename_to_perm_level(perm.codename) <= perm_level:
-                permission_list.append(perm)
-
-        return permission_list
+        return [
+            perm
+            for perm in self.permissions
+            if codename_to_perm_level(perm.codename) <= perm_level
+        ]
 
     def get_special_role(self, codename: str) -> Permission | None:
         for perm in self.permissions:
@@ -90,9 +89,8 @@ class ModelPermissions:
 
 class GroupPermissions:
     def __init__(self, group: Group, model_permission: ModelPermission):
-        """
-            Helper to use Django Groups as a cascading permission structure.
-        """
+        """Helper to use Django Groups as a cascading permission structure."""
+
         self.group = group
         self.model_permissions = ModelPermissions(model_permission)
         self.group_perms = self.group.permissions.all()
@@ -105,18 +103,14 @@ class GroupPermissions:
             self.set_group_perms()
 
     def has_special_role(self, codename: str) -> bool:
-        for perm in self.group_perms:
-            if perm.codename == codename:
-                return True
-
-        return False
+        return any(perm.codename == codename for perm in self.group_perms)
 
     def perm_level(self) -> VALID_PERMISSION_LEVELS:
-        codename_list = []
-
-        for perm in self.group_perms:
-            if perm.codename.split('_')[-1] == self.model_permissions.model_name:
-                codename_list.append(perm.codename)
+        codename_list = [
+            perm.codename
+            for perm in self.group_perms
+            if perm.codename.split('_')[-1] == self.model_permissions.model_name
+        ]
 
         return codename_list_to_perm_level(codename_list)
 
@@ -169,9 +163,8 @@ class GroupPermissions:
 
 class UserPermissionHelper:
     def __init__(self, user: User, model_permission: ModelPermission):
-        """
-            Helper to query user's current cascading permissions
-        """
+        """Helper to query user's current cascading permissions"""
+
         self.user = user
         self.model_permissions = ModelPermissions(model_permission)
         self.user_perms = self.get_user_perms()
@@ -180,11 +173,11 @@ class UserPermissionHelper:
         return Permission.objects.filter(group__user=self.user).distinct()
 
     def perm_level(self) -> VALID_PERMISSION_LEVELS:
-        codename_list = []
-
-        for perm in self.user_perms:
-            if perm.codename.split('_')[-1] == self.model_permissions.model_name:
-                codename_list.append(perm.codename)
+        codename_list = [
+            perm.codename
+            for perm in self.user_perms
+            if perm.codename.split('_')[-1] == self.model_permissions.model_name
+        ]
 
         return codename_list_to_perm_level(codename_list)