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

django_spire/auth/tests/test_views.py

@@ -0,0 +1,406 @@
+from __future__ import annotations
+
+from django.contrib.auth import get_user
+from django.urls import reverse
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class LoginViewTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.client.logout()
+        self.user = create_user(username='testuser', email='test@example.com')
+        self.user.set_password('testpassword123')
+        self.user.save()
+
+    def test_login_page_loads(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:admin:login'))
+        assert response.status_code == 200
+
+    def test_login_with_valid_credentials(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'testpassword123'}
+        )
+        assert response.status_code == 302
+
+    def test_login_with_invalid_credentials(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'wrongpassword'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_nonexistent_user(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'nonexistent', 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_empty_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': '', 'password': 'testpassword123'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_empty_password(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': ''}
+        )
+        assert response.status_code == 200
+
+    def test_login_inactive_user(self) -> None:
+        self.user.is_active = False
+        self.user.save()
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'testpassword123'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_whitespace_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': '   ', 'password': 'testpassword123'}
+        )
+        assert response.status_code == 200
+
+    def test_login_case_sensitive_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'TESTUSER', 'password': 'testpassword123'}
+        )
+        assert response.status_code == 200
+
+    def test_login_case_sensitive_password(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'TESTPASSWORD123'}
+        )
+        assert response.status_code == 200
+
+    def test_login_sets_session(self) -> None:
+        self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'testpassword123'}
+        )
+        user = get_user(self.client)
+        assert user.is_authenticated
+
+    def test_login_with_sql_injection_attempt(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': "'; DROP TABLE users; --", 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_xss_attempt(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': '<script>alert("xss")</script>', 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_very_long_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'a' * 1000, 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_very_long_password(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'a' * 1000}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_unicode_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'tëstüsér', 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_unicode_password(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'pässwörd'}
+        )
+        assert response.status_code == 200
+
+    def test_login_get_request_does_not_authenticate(self) -> None:
+        response = self.client.get(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'testuser', 'password': 'testpassword123'}
+        )
+        user = get_user(self.client)
+        assert not user.is_authenticated
+        assert response.status_code == 200
+
+    def test_login_with_null_bytes(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'test\x00user', 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_newline_in_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'test\nuser', 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+    def test_login_with_tab_in_username(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:login'),
+            data={'username': 'test\tuser', 'password': 'password'}
+        )
+        assert response.status_code == 200
+
+
+class PasswordChangeViewTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser')
+        self.user.set_password('oldpassword123')
+        self.user.save()
+        self.client.force_login(self.user)
+
+    def test_password_change_page_loads(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:admin:password_change'))
+        assert response.status_code == 200
+
+    def test_password_change_success(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': 'newpassword456',
+                'new_password2': 'newpassword456'
+            }
+        )
+        assert response.status_code == 302
+        self.user.refresh_from_db()
+        assert self.user.check_password('newpassword456')
+
+    def test_password_change_wrong_old_password(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'wrongoldpassword',
+                'new_password1': 'newpassword456',
+                'new_password2': 'newpassword456'
+            }
+        )
+        assert response.status_code == 200
+        self.user.refresh_from_db()
+        assert self.user.check_password('oldpassword123')
+
+    def test_password_change_mismatched_passwords(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': 'newpassword456',
+                'new_password2': 'differentpassword789'
+            }
+        )
+        assert response.status_code == 200
+
+    def test_password_change_empty_new_password(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': '',
+                'new_password2': ''
+            }
+        )
+        assert response.status_code == 200
+
+    def test_password_change_requires_login(self) -> None:
+        self.client.logout()
+        response = self.client.get(reverse('django_spire:auth:admin:password_change'))
+        assert response.status_code == 302
+
+    def test_password_change_same_as_old(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': 'oldpassword123',
+                'new_password2': 'oldpassword123'
+            }
+        )
+        assert response.status_code in (200, 302)
+
+    def test_password_change_with_unicode(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': 'nëwpässwörd456',
+                'new_password2': 'nëwpässwörd456'
+            }
+        )
+        assert response.status_code == 302
+        self.user.refresh_from_db()
+        assert self.user.check_password('nëwpässwörd456')
+
+    def test_password_change_very_long_password(self) -> None:
+        long_password = 'a' * 128
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': long_password,
+                'new_password2': long_password
+            }
+        )
+        assert response.status_code == 302
+
+    def test_password_change_with_spaces(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': 'new password 456',
+                'new_password2': 'new password 456'
+            }
+        )
+        assert response.status_code == 302
+        self.user.refresh_from_db()
+        assert self.user.check_password('new password 456')
+
+    def test_password_change_preserves_session(self) -> None:
+        self.client.post(
+            reverse('django_spire:auth:admin:password_change'),
+            data={
+                'old_password': 'oldpassword123',
+                'new_password1': 'newpassword456',
+                'new_password2': 'newpassword456'
+            }
+        )
+        user = get_user(self.client)
+        assert user.is_authenticated
+
+
+class PasswordChangeDoneViewTestCase(BaseTestCase):
+    def test_password_change_done_page_loads(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:admin:password_change_done'))
+        assert response.status_code == 200
+
+
+class PasswordResetViewTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser', email='test@example.com')
+
+    def test_password_reset_page_loads(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:admin:password_reset'))
+        assert response.status_code == 200
+
+    def test_password_reset_with_valid_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': 'test@example.com'}
+        )
+        assert response.status_code == 302
+
+    def test_password_reset_with_nonexistent_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': 'nonexistent@example.com'}
+        )
+        assert response.status_code == 302
+
+    def test_password_reset_with_empty_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': ''}
+        )
+        assert response.status_code == 200
+
+    def test_password_reset_with_invalid_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': 'invalid-email'}
+        )
+        assert response.status_code == 200
+
+    def test_password_reset_with_uppercase_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': 'TEST@EXAMPLE.COM'}
+        )
+        assert response.status_code == 302
+
+    def test_password_reset_with_mixed_case_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': 'Test@Example.Com'}
+        )
+        assert response.status_code == 302
+
+    def test_password_reset_with_whitespace_email(self) -> None:
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': '  test@example.com  '}
+        )
+        assert response.status_code in (200, 302)
+
+    def test_password_reset_inactive_user(self) -> None:
+        self.user.is_active = False
+        self.user.save()
+        response = self.client.post(
+            reverse('django_spire:auth:admin:password_reset'),
+            data={'email': 'test@example.com'}
+        )
+        assert response.status_code == 302
+
+
+class PasswordResetDoneViewTestCase(BaseTestCase):
+    def test_password_reset_done_page_loads(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:admin:password_reset_done'))
+        assert response.status_code == 200
+
+
+class LogoutRedirectViewTestCase(BaseTestCase):
+    def test_logout_redirects(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:redirect:logout'))
+        assert response.status_code == 302
+
+    def test_logout_logs_out_user(self) -> None:
+        self.client.get(reverse('django_spire:auth:redirect:logout'))
+        response = self.client.get(reverse('django_spire:auth:admin:password_change'))
+        assert response.status_code != 200
+
+    def test_logout_redirects_to_login(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:redirect:logout'))
+        assert 'login' in response.url.lower()
+
+    def test_logout_clears_session(self) -> None:
+        self.client.get(reverse('django_spire:auth:redirect:logout'))
+        user = get_user(self.client)
+        assert not user.is_authenticated
+
+
+class LoginRedirectViewTestCase(BaseTestCase):
+    def test_login_redirect_for_authenticated_user(self) -> None:
+        response = self.client.get(reverse('django_spire:auth:redirect:login'))
+        assert response.status_code == 302
+
+    def test_login_redirect_for_unauthenticated_user(self) -> None:
+        self.client.logout()
+        response = self.client.get(reverse('django_spire:auth:redirect:login'))
+        assert response.status_code == 302

django_spire/auth/urls/admin_urls.py

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

django_spire/auth/urls/redirect_urls.py

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

django_spire/auth/user/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 from django_spire.utils import check_required_apps

django_spire/auth/user/forms.py

@@ -69,6 +69,15 @@ class EditUserForm(forms.ModelForm):
 
 
 class RegisterUserForm(forms.ModelForm):
+    def clean_email(self) -> str:
+        email = self.cleaned_data.get('email')
+
+        if not email:
+            message = 'Email is required.'
+            raise forms.ValidationError(message)
+
+        return email
+
     def clean_password(self) -> str:
         password = self.cleaned_data.get('password')
 

django_spire/auth/user/models.py

@@ -14,7 +14,7 @@ class AuthUser(User, ActivityMixin):
     @classmethod
     def base_breadcrumb(cls) -> Breadcrumbs:
         crumbs = Breadcrumbs()
-        crumbs.add_breadcrumb('Users', reverse('django_spire:auth:user:list'))
+        crumbs.add_breadcrumb('Users', reverse('django_spire:auth:user:page:list'))
         return crumbs
 
     def breadcrumbs(self) -> Breadcrumbs:

django_spire/auth/user/services/services.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from django_spire.contrib.service import BaseDjangoModelService

django_spire/auth/user/tests/factories.py

@@ -7,7 +7,7 @@ def create_user(
     username: str,
     **kwargs
 ) -> AuthUser:
-    user, created = AuthUser.objects.get_or_create(
+    user, _ = AuthUser.objects.get_or_create(
         username=username,
         defaults={
             **kwargs
@@ -18,20 +18,21 @@ def create_user(
 
 
 def create_super_user(password: str = 'stratus', **kwargs) -> AuthUser:
-    user, created = AuthUser.objects.get_or_create(
+    defaults = {
+        'email': 'bobert@stratusadv.com',
+        'first_name': 'Bob',
+        'last_name': 'Robertson',
+        'is_superuser': True,
+        'is_staff': True,
+        **kwargs
+    }
+
+    user, _ = AuthUser.objects.update_or_create(
         username='stratus',
-        defaults={
-            'email': 'bobert@stratusadv.com',
-            'first_name': 'Bob',
-            'last_name': 'Robertson',
-            'is_superuser': True,
-            'is_staff': True,
-            **kwargs
-        }
+        defaults=defaults
     )
 
-    if created:
-        user.set_password(password)
-        user.save()
+    user.set_password(password)
+    user.save()
 
     return user

django_spire/auth/user/tests/test_factories.py

@@ -1,7 +1,171 @@
 from __future__ import annotations
 
+from django_spire.auth.user.models import AuthUser
+from django_spire.auth.user.tests.factories import create_super_user, create_user
 from django_spire.core.tests.test_cases import BaseTestCase
 
 
-class UserAccountFactoriesUnitTestCase(BaseTestCase):
-    pass
+class CreateUserTestCase(BaseTestCase):
+    def test_creates_user(self) -> None:
+        user = create_user(username='testuser')
+        assert isinstance(user, AuthUser)
+        assert AuthUser.objects.filter(username='testuser').exists()
+
+    def test_creates_user_with_username(self) -> None:
+        user = create_user(username='myuser')
+        assert user.username == 'myuser'
+
+    def test_creates_user_with_kwargs(self) -> None:
+        user = create_user(
+            username='testuser',
+            first_name='Test',
+            last_name='User',
+            email='test@example.com'
+        )
+        assert user.first_name == 'Test'
+        assert user.last_name == 'User'
+        assert user.email == 'test@example.com'
+
+    def test_returns_existing_user_if_exists(self) -> None:
+        user1 = create_user(username='existinguser')
+        user2 = create_user(username='existinguser')
+        assert user1.pk == user2.pk
+
+    def test_get_or_create_behavior(self) -> None:
+        user1 = create_user(username='getorcreate', first_name='First')
+        user2 = create_user(username='getorcreate', first_name='Different')
+        assert user1.pk == user2.pk
+        assert user1.first_name == 'First'
+
+    def test_creates_with_is_active_true(self) -> None:
+        user = create_user(username='activeuser', is_active=True)
+        assert user.is_active
+
+    def test_creates_with_is_active_false(self) -> None:
+        user = create_user(username='inactiveuser', is_active=False)
+        assert not user.is_active
+
+    def test_user_has_pk(self) -> None:
+        user = create_user(username='pkuser')
+        assert user.pk is not None
+
+    def test_creates_unique_users(self) -> None:
+        user1 = create_user(username='user1')
+        user2 = create_user(username='user2')
+        assert user1.pk != user2.pk
+
+    def test_creates_with_unicode_username(self) -> None:
+        user = create_user(username='tëstüsér')
+        assert user.username == 'tëstüsér'
+
+    def test_creates_with_email(self) -> None:
+        user = create_user(username='emailuser', email='email@example.com')
+        assert user.email == 'email@example.com'
+
+    def test_creates_with_empty_email(self) -> None:
+        user = create_user(username='noemail', email='')
+        assert user.email == ''
+
+    def test_creates_with_staff_status(self) -> None:
+        user = create_user(username='staffuser', is_staff=True)
+        assert user.is_staff
+
+    def test_creates_without_staff_status(self) -> None:
+        user = create_user(username='nonstaffuser', is_staff=False)
+        assert not user.is_staff
+
+    def test_creates_with_superuser_status(self) -> None:
+        user = create_user(username='superuser', is_superuser=True)
+        assert user.is_superuser
+
+    def test_creates_without_superuser_status(self) -> None:
+        user = create_user(username='normaluser', is_superuser=False)
+        assert not user.is_superuser
+
+    def test_user_is_persisted(self) -> None:
+        user = create_user(username='persisteduser')
+        assert AuthUser.objects.filter(pk=user.pk).exists()
+
+    def test_creates_with_long_username(self) -> None:
+        long_username = 'a' * 150
+        user = create_user(username=long_username)
+        assert user.username == long_username
+
+    def test_creates_with_special_characters_username(self) -> None:
+        user = create_user(username='test.user@example.com')
+        assert user.username == 'test.user@example.com'
+
+
+class CreateSuperUserTestCase(BaseTestCase):
+    def test_creates_superuser(self) -> None:
+        user = create_super_user()
+        assert isinstance(user, AuthUser)
+        assert user.is_superuser
+
+    def test_superuser_is_staff(self) -> None:
+        user = create_super_user()
+        assert user.is_staff
+
+    def test_superuser_default_username(self) -> None:
+        user = create_super_user()
+        assert user.username == 'stratus'
+
+    def test_superuser_default_email(self) -> None:
+        user = create_super_user()
+        assert user.email == 'bobert@stratusadv.com'
+
+    def test_superuser_default_names(self) -> None:
+        user = create_super_user()
+        assert user.first_name == 'Bob'
+        assert user.last_name == 'Robertson'
+
+    def test_superuser_default_password(self) -> None:
+        user = create_super_user()
+        assert user.check_password('stratus')
+
+    def test_superuser_custom_password(self) -> None:
+        user = create_super_user(password='custompassword')  # noqa: S106
+        assert user.check_password('custompassword')
+
+    def test_superuser_returns_existing(self) -> None:
+        user1 = create_super_user()
+        user2 = create_super_user()
+        assert user1.pk == user2.pk
+
+    def test_superuser_has_pk(self) -> None:
+        user = create_super_user()
+        assert user.pk is not None
+
+    def test_superuser_is_active(self) -> None:
+        user = create_super_user()
+        assert user.is_active
+
+    def test_superuser_has_all_permissions(self) -> None:
+        user = create_super_user()
+        assert user.has_perm('any.permission')
+
+    def test_superuser_with_custom_kwargs(self) -> None:
+        user = create_super_user(first_name='Custom', last_name='Name')
+        assert user.first_name in ('Bob', 'Custom')
+
+    def test_superuser_is_persisted(self) -> None:
+        user = create_super_user()
+        assert AuthUser.objects.filter(pk=user.pk).exists()
+
+    def test_superuser_can_authenticate(self) -> None:
+        user = create_super_user()
+        assert user.check_password('stratus')
+
+    def test_superuser_password_is_hashed(self) -> None:
+        user = create_super_user()
+        assert user.password != 'stratus'  # noqa: S105
+
+    def test_multiple_calls_same_user(self) -> None:
+        users = [create_super_user() for _ in range(5)]
+        pks = [u.pk for u in users]
+        assert len(set(pks)) == 1
+
+    def test_superuser_get_full_name(self) -> None:
+        user = create_super_user()
+        full_name = user.get_full_name()
+        assert 'Bob' in full_name or 'Robertson' in full_name