django-spire 0.23.7__py3-none-any.whl → 0.23.9__py3-none-any.whl

django_spire/auth/user/tests/test_models.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import pytest
+
+from django.db import IntegrityError
+
+from django_spire.auth.group.models import AuthGroup
+from django_spire.auth.user.models import AuthUser
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class AuthUserModelTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(
+            username='testuser',
+            first_name='Test',
+            last_name='User',
+            email='test@example.com'
+        )
+
+    def test_meta_proxy(self) -> None:
+        assert AuthUser._meta.proxy
+
+    def test_meta_verbose_name(self) -> None:
+        assert AuthUser._meta.verbose_name == 'Auth User'
+        assert AuthUser._meta.verbose_name_plural == 'Auth Users'
+
+    def test_get_full_name(self) -> None:
+        assert self.user.get_full_name() == 'Test User'
+
+    def test_get_full_name_first_only(self) -> None:
+        user = create_user(username='firstonly', first_name='First', last_name='')
+        assert 'First' in user.get_full_name()
+
+    def test_get_full_name_last_only(self) -> None:
+        user = create_user(username='lastonly', first_name='', last_name='Last')
+        assert 'Last' in user.get_full_name()
+
+    def test_get_full_name_empty(self) -> None:
+        user = create_user(username='noname', first_name='', last_name='')
+        assert user.get_full_name() == ''
+
+    def test_services_class_attribute(self) -> None:
+        assert AuthUser.services is not None
+
+    def test_user_creation(self) -> None:
+        user = create_user(
+            username='newuser',
+            first_name='New',
+            last_name='User',
+            email='new@example.com'
+        )
+        assert user.pk is not None
+        assert AuthUser.objects.filter(pk=user.pk).exists()
+
+    def test_user_update(self) -> None:
+        self.user.first_name = 'Updated'
+        self.user.save()
+        self.user.refresh_from_db()
+        assert self.user.first_name == 'Updated'
+
+    def test_user_deletion(self) -> None:
+        user_pk = self.user.pk
+        self.user.delete()
+        assert not AuthUser.objects.filter(pk=user_pk).exists()
+
+    def test_user_email(self) -> None:
+        assert self.user.email == 'test@example.com'
+
+    def test_user_is_active_default(self) -> None:
+        user = create_user(username='activeuser')
+        assert user.is_active
+
+    def test_user_is_active_false(self) -> None:
+        user = create_user(username='inactiveuser', is_active=False)
+        assert not user.is_active
+
+    def test_user_groups_relationship(self) -> None:
+        group = AuthGroup.objects.create(name='Test Group')
+        self.user.groups.add(group)
+        assert group in self.user.groups.all()
+
+    def test_user_multiple_groups(self) -> None:
+        group1 = AuthGroup.objects.create(name='Group 1')
+        group2 = AuthGroup.objects.create(name='Group 2')
+        self.user.groups.add(group1, group2)
+        assert self.user.groups.count() == 2
+
+    def test_user_remove_from_group(self) -> None:
+        group = AuthGroup.objects.create(name='Test Group')
+        self.user.groups.add(group)
+        self.user.groups.remove(group)
+        assert group not in self.user.groups.all()
+
+    def test_user_clear_groups(self) -> None:
+        group1 = AuthGroup.objects.create(name='Group 1')
+        group2 = AuthGroup.objects.create(name='Group 2')
+        self.user.groups.add(group1, group2)
+        self.user.groups.clear()
+        assert self.user.groups.count() == 0
+
+    def test_user_username_unique(self) -> None:
+        with pytest.raises(IntegrityError):
+            AuthUser.objects.create(username='testuser')
+
+    def test_user_password_hashing(self) -> None:
+        user = create_user(username='passworduser')
+        user.set_password('testpassword123')
+        user.save()
+        assert user.check_password('testpassword123')
+        assert not user.check_password('wrongpassword')
+
+    def test_user_last_login_initially_none(self) -> None:
+        user = create_user(username='nologinuser')
+        assert user.last_login is None
+
+    def test_breadcrumbs_returns_breadcrumbs(self) -> None:
+        crumbs = self.user.breadcrumbs()
+        assert crumbs is not None
+
+    def test_breadcrumbs_without_pk(self) -> None:
+        unsaved_user = AuthUser(username='unsaved', first_name='Unsaved')
+        crumbs = unsaved_user.breadcrumbs()
+        assert crumbs is not None
+
+    def test_breadcrumbs_contains_user_name(self) -> None:
+        crumbs = self.user.breadcrumbs()
+        names = [c.name for c in crumbs.data]
+        assert 'Test User' in names
+
+    def test_base_breadcrumb_returns_breadcrumbs(self) -> None:
+        crumbs = AuthUser.base_breadcrumb()
+        assert crumbs is not None
+
+    def test_base_breadcrumb_contains_users(self) -> None:
+        crumbs = AuthUser.base_breadcrumb()
+        names = [c.name for c in crumbs.data]
+        assert 'Users' in names
+
+    def test_user_inheritance_from_django_user(self) -> None:
+        from django.contrib.auth.models import User
+        assert issubclass(AuthUser, User)
+
+    def test_activity_mixin(self) -> None:
+        assert hasattr(self.user, 'add_activity')
+
+    def test_user_get_short_name(self) -> None:
+        assert self.user.get_short_name() == 'Test'
+
+    def test_user_str_representation(self) -> None:
+        assert str(self.user) == 'testuser'
+
+    def test_user_email_user(self) -> None:
+        assert hasattr(self.user, 'email_user')
+
+    def test_user_has_perm(self) -> None:
+        assert hasattr(self.user, 'has_perm')
+
+    def test_user_has_perms(self) -> None:
+        assert hasattr(self.user, 'has_perms')
+
+    def test_user_has_module_perms(self) -> None:
+        assert hasattr(self.user, 'has_module_perms')
+
+    def test_user_is_anonymous(self) -> None:
+        assert not self.user.is_anonymous
+
+    def test_user_is_authenticated(self) -> None:
+        assert self.user.is_authenticated
+
+    def test_user_date_joined(self) -> None:
+        assert self.user.date_joined is not None
+
+    def test_user_username_max_length(self) -> None:
+        max_length = AuthUser._meta.get_field('username').max_length
+        assert max_length == 150
+
+    def test_user_first_name_max_length(self) -> None:
+        max_length = AuthUser._meta.get_field('first_name').max_length
+        assert max_length == 150
+
+    def test_user_last_name_max_length(self) -> None:
+        max_length = AuthUser._meta.get_field('last_name').max_length
+        assert max_length == 150
+
+    def test_user_email_max_length(self) -> None:
+        max_length = AuthUser._meta.get_field('email').max_length
+        assert max_length == 254
+
+    def test_user_with_unicode_names(self) -> None:
+        user = create_user(
+            username='unicodeuser',
+            first_name='Tëst',
+            last_name='Üsér'
+        )
+        assert user.first_name == 'Tëst'
+        assert user.last_name == 'Üsér'
+        assert 'Tëst' in user.get_full_name()
+
+    def test_user_refresh_from_db(self) -> None:
+        original_name = self.user.first_name
+        AuthUser.objects.filter(pk=self.user.pk).update(first_name='Changed')
+        self.user.refresh_from_db()
+        assert self.user.first_name == 'Changed'
+        assert self.user.first_name != original_name
+
+    def test_user_get_or_create(self) -> None:
+        user, created = AuthUser.objects.get_or_create(
+            username='getorcreate',
+            defaults={'first_name': 'Get', 'last_name': 'OrCreate'}
+        )
+        assert created
+        user2, created2 = AuthUser.objects.get_or_create(
+            username='getorcreate',
+            defaults={'first_name': 'Different', 'last_name': 'Name'}
+        )
+        assert not created2
+        assert user.pk == user2.pk
+
+    def test_user_exists(self) -> None:
+        assert AuthUser.objects.filter(username='testuser').exists()
+        assert not AuthUser.objects.filter(username='nonexistent').exists()
+
+    def test_user_count(self) -> None:
+        initial_count = AuthUser.objects.count()
+        create_user(username='countuser1')
+        create_user(username='countuser2')
+        assert AuthUser.objects.count() == initial_count + 2
+
+    def test_user_filter_by_is_active(self) -> None:
+        create_user(username='active1', is_active=True)
+        create_user(username='inactive1', is_active=False)
+        active_users = AuthUser.objects.filter(is_active=True)
+        inactive_users = AuthUser.objects.filter(is_active=False)
+        assert active_users.filter(username='active1').exists()
+        assert inactive_users.filter(username='inactive1').exists()
+
+    def test_user_order_by_username(self) -> None:
+        create_user(username='zebra')
+        create_user(username='alpha')
+        users = AuthUser.objects.order_by('username')
+        usernames = list(users.values_list('username', flat=True))
+        assert usernames == sorted(usernames)
+
+    def test_user_permissions_relationship(self) -> None:
+        assert hasattr(self.user, 'user_permissions')
+
+    def test_user_set_unusable_password(self) -> None:
+        self.user.set_unusable_password()
+        assert not self.user.has_usable_password()
+
+    def test_user_check_password_with_unusable(self) -> None:
+        self.user.set_unusable_password()
+        assert not self.user.check_password('anypassword')

django_spire/auth/user/tests/test_services.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from django_spire.auth.group.models import AuthGroup
+from django_spire.auth.user.models import AuthUser
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class AuthUserServiceTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user1 = create_user(
+            username='user1',
+            first_name='Alice',
+            last_name='Smith',
+            is_active=True
+        )
+        self.user2 = create_user(
+            username='user2',
+            first_name='Bob',
+            last_name='Jones',
+            is_active=True
+        )
+        self.inactive_user = create_user(
+            username='inactive',
+            first_name='Charlie',
+            last_name='Brown',
+            is_active=False
+        )
+
+    def test_get_user_choices_returns_list(self) -> None:
+        choices = AuthUser.services.get_user_choices()
+        assert isinstance(choices, list)
+
+    def test_get_user_choices_format(self) -> None:
+        choices = AuthUser.services.get_user_choices()
+        for choice in choices:
+            assert len(choice) == 2
+            assert isinstance(choice[0], int)
+            assert isinstance(choice[1], str)
+
+    def test_get_user_choices_excludes_inactive(self) -> None:
+        choices = AuthUser.services.get_user_choices()
+        user_ids = [c[0] for c in choices]
+        assert self.inactive_user.pk not in user_ids
+
+    def test_get_user_choices_includes_active(self) -> None:
+        choices = AuthUser.services.get_user_choices()
+        user_ids = [c[0] for c in choices]
+        assert self.user1.pk in user_ids
+        assert self.user2.pk in user_ids
+
+    def test_get_user_choices_by_group(self) -> None:
+        group = AuthGroup.objects.create(name='Test Group')
+        self.user1.groups.add(group)
+
+        choices = AuthUser.services.get_user_choices_by_group(group)
+        user_ids = [c[0] for c in choices]
+
+        assert self.user1.pk in user_ids
+        assert self.user2.pk not in user_ids
+
+    def test_get_user_choices_by_group_empty(self) -> None:
+        group = AuthGroup.objects.create(name='Empty Group')
+        choices = AuthUser.services.get_user_choices_by_group(group)
+        assert len(choices) == 0
+
+    def test_get_user_choices_by_group_multiple_users(self) -> None:
+        group = AuthGroup.objects.create(name='Multi User Group')
+        self.user1.groups.add(group)
+        self.user2.groups.add(group)
+
+        choices = AuthUser.services.get_user_choices_by_group(group)
+        user_ids = [c[0] for c in choices]
+
+        assert self.user1.pk in user_ids
+        assert self.user2.pk in user_ids
+
+    def test_get_user_choices_by_group_excludes_inactive(self) -> None:
+        group = AuthGroup.objects.create(name='Mixed Group')
+        self.user1.groups.add(group)
+        self.inactive_user.groups.add(group)
+
+        choices = AuthUser.services.get_user_choices_by_group(group)
+        user_ids = [c[0] for c in choices]
+
+        assert self.user1.pk in user_ids
+        assert self.inactive_user.pk not in user_ids
+
+    def test_get_user_choices_returns_full_name(self) -> None:
+        choices = AuthUser.services.get_user_choices()
+        user1_choice = next((c for c in choices if c[0] == self.user1.pk), None)
+        assert user1_choice is not None
+        assert user1_choice[1] == 'Alice Smith'
+
+    def test_get_user_choices_with_no_active_users(self) -> None:
+        AuthUser.objects.filter(is_active=True).update(is_active=False)
+        choices = AuthUser.services.get_user_choices()
+        assert len(choices) == 0
+
+    def test_get_user_choices_user_in_multiple_groups(self) -> None:
+        group1 = AuthGroup.objects.create(name='Group 1')
+        group2 = AuthGroup.objects.create(name='Group 2')
+        self.user1.groups.add(group1, group2)
+
+        choices1 = AuthUser.services.get_user_choices_by_group(group1)
+        choices2 = AuthUser.services.get_user_choices_by_group(group2)
+
+        assert any(c[0] == self.user1.pk for c in choices1)
+        assert any(c[0] == self.user1.pk for c in choices2)
+
+    def test_get_user_choices_empty_name(self) -> None:
+        user = create_user(username='emptyname', first_name='', last_name='')
+        choices = AuthUser.services.get_user_choices()
+        user_choice = next((c for c in choices if c[0] == user.pk), None)
+        assert user_choice is not None
+        assert user_choice[1] == ''
+
+    def test_get_user_choices_unicode_name(self) -> None:
+        user = create_user(username='unicode', first_name='Tëst', last_name='Üsér')
+        choices = AuthUser.services.get_user_choices()
+        user_choice = next((c for c in choices if c[0] == user.pk), None)
+        assert user_choice is not None
+        assert 'Tëst' in user_choice[1]
+        assert 'Üsér' in user_choice[1]
+
+    def test_get_user_choices_first_name_only(self) -> None:
+        user = create_user(username='firstonly', first_name='First', last_name='')
+        choices = AuthUser.services.get_user_choices()
+        user_choice = next((c for c in choices if c[0] == user.pk), None)
+        assert user_choice is not None
+        assert 'First' in user_choice[1]
+
+    def test_get_user_choices_last_name_only(self) -> None:
+        user = create_user(username='lastonly', first_name='', last_name='Last')
+        choices = AuthUser.services.get_user_choices()
+        user_choice = next((c for c in choices if c[0] == user.pk), None)
+        assert user_choice is not None
+        assert 'Last' in user_choice[1]
+
+    def test_get_user_choices_by_group_nonexistent_group(self) -> None:
+        group = AuthGroup.objects.create(name='Temp Group')
+        group_pk = group.pk
+        group.delete()
+        new_group = AuthGroup(pk=group_pk, name='Fake')
+        choices = AuthUser.services.get_user_choices_by_group(new_group)
+        assert len(choices) == 0
+
+    def test_get_user_choices_many_users(self) -> None:
+        for i in range(50):
+            create_user(username=f'manyuser{i}', first_name=f'User{i}', last_name='Test')
+        choices = AuthUser.services.get_user_choices()
+        assert len(choices) >= 50
+
+    def test_get_user_choices_by_group_after_user_removal(self) -> None:
+        group = AuthGroup.objects.create(name='Removal Group')
+        self.user1.groups.add(group)
+
+        choices_before = AuthUser.services.get_user_choices_by_group(group)
+        assert any(c[0] == self.user1.pk for c in choices_before)
+
+        self.user1.groups.remove(group)
+
+        choices_after = AuthUser.services.get_user_choices_by_group(group)
+        assert not any(c[0] == self.user1.pk for c in choices_after)
+
+    def test_get_user_choices_by_group_after_user_deactivation(self) -> None:
+        group = AuthGroup.objects.create(name='Deactivation Group')
+        self.user1.groups.add(group)
+
+        choices_before = AuthUser.services.get_user_choices_by_group(group)
+        assert any(c[0] == self.user1.pk for c in choices_before)
+
+        self.user1.is_active = False
+        self.user1.save()
+
+        choices_after = AuthUser.services.get_user_choices_by_group(group)
+        assert not any(c[0] == self.user1.pk for c in choices_after)
+
+    def test_service_obj_class_is_auth_user(self) -> None:
+        assert AuthUser.services.obj_class == AuthUser
+
+    def test_get_user_choices_order(self) -> None:
+        choices = AuthUser.services.get_user_choices()
+        assert len(choices) > 0
+
+    def test_get_user_choices_by_group_returns_list(self) -> None:
+        group = AuthGroup.objects.create(name='List Group')
+        choices = AuthUser.services.get_user_choices_by_group(group)
+        assert isinstance(choices, list)
+
+    def test_get_user_choices_by_group_format(self) -> None:
+        group = AuthGroup.objects.create(name='Format Group')
+        self.user1.groups.add(group)
+        choices = AuthUser.services.get_user_choices_by_group(group)
+        for choice in choices:
+            assert len(choice) == 2
+            assert isinstance(choice[0], int)
+            assert isinstance(choice[1], str)

django_spire/auth/user/tests/test_tools.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import Group
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.auth.user.tools import add_user_to_all_user_group
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class AddUserToAllUserGroupTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser')
+
+    def test_creates_all_users_group_if_not_exists(self) -> None:
+        Group.objects.filter(name='All Users').delete()
+        add_user_to_all_user_group(self.user)
+        assert Group.objects.filter(name='All Users').exists()
+
+    def test_adds_user_to_existing_group(self) -> None:
+        group = Group.objects.create(name='All Users')
+        add_user_to_all_user_group(self.user)
+        assert self.user in group.user_set.all()
+
+    def test_user_in_all_users_group(self) -> None:
+        add_user_to_all_user_group(self.user)
+        group = Group.objects.get(name='All Users')
+        assert self.user in group.user_set.all()
+
+    def test_idempotent_add(self) -> None:
+        add_user_to_all_user_group(self.user)
+        add_user_to_all_user_group(self.user)
+        group = Group.objects.get(name='All Users')
+        assert group.user_set.filter(pk=self.user.pk).count() == 1
+
+    def test_multiple_users_added(self) -> None:
+        user2 = create_user(username='testuser2')
+        add_user_to_all_user_group(self.user)
+        add_user_to_all_user_group(user2)
+        group = Group.objects.get(name='All Users')
+        assert group.user_set.count() >= 2
+        assert self.user in group.user_set.all()
+        assert user2 in group.user_set.all()
+
+    def test_user_remains_in_other_groups(self) -> None:
+        other_group = Group.objects.create(name='Other Group')
+        self.user.groups.add(other_group)
+        add_user_to_all_user_group(self.user)
+        assert other_group in self.user.groups.all()
+
+    def test_group_created_with_exact_name(self) -> None:
+        Group.objects.filter(name='All Users').delete()
+        add_user_to_all_user_group(self.user)
+        group = Group.objects.get(name='All Users')
+        assert group.name == 'All Users'
+
+    def test_inactive_user_can_be_added(self) -> None:
+        inactive_user = create_user(username='inactive', is_active=False)
+        add_user_to_all_user_group(inactive_user)
+        group = Group.objects.get(name='All Users')
+        assert inactive_user in group.user_set.all()
+
+    def test_does_not_affect_other_groups(self) -> None:
+        other_group = Group.objects.create(name='Other Group')
+        initial_count = other_group.user_set.count()
+        add_user_to_all_user_group(self.user)
+        assert other_group.user_set.count() == initial_count
+
+    def test_user_not_added_to_other_groups(self) -> None:
+        other_group = Group.objects.create(name='Other Group')
+        add_user_to_all_user_group(self.user)
+        assert self.user not in other_group.user_set.all()
+
+    def test_multiple_calls_single_group_entry(self) -> None:
+        for _ in range(5):
+            add_user_to_all_user_group(self.user)
+        group = Group.objects.get(name='All Users')
+        assert group.user_set.filter(pk=self.user.pk).count() == 1
+
+    def test_group_persists_after_function_call(self) -> None:
+        Group.objects.filter(name='All Users').delete()
+        add_user_to_all_user_group(self.user)
+        assert Group.objects.filter(name='All Users').exists()
+
+    def test_user_membership_persists(self) -> None:
+        add_user_to_all_user_group(self.user)
+        self.user.refresh_from_db()
+        group = Group.objects.get(name='All Users')
+        assert group in self.user.groups.all()
+
+    def test_does_not_remove_existing_members(self) -> None:
+        existing_user = create_user(username='existinguser')
+        group = Group.objects.create(name='All Users')
+        group.user_set.add(existing_user)
+
+        add_user_to_all_user_group(self.user)
+
+        assert existing_user in group.user_set.all()
+        assert self.user in group.user_set.all()
+
+    def test_works_with_staff_user(self) -> None:
+        staff_user = create_user(username='staffuser', is_staff=True)
+        add_user_to_all_user_group(staff_user)
+        group = Group.objects.get(name='All Users')
+        assert staff_user in group.user_set.all()
+
+    def test_works_with_superuser(self) -> None:
+        superuser = create_user(username='superuser', is_superuser=True)
+        add_user_to_all_user_group(superuser)
+        group = Group.objects.get(name='All Users')
+        assert superuser in group.user_set.all()
+
+    def test_case_sensitive_group_name(self) -> None:
+        Group.objects.create(name='all users')
+        Group.objects.filter(name='All Users').delete()
+        add_user_to_all_user_group(self.user)
+        assert Group.objects.filter(name='All Users').exists()
+        assert Group.objects.filter(name='all users').exists()
+
+    def test_many_users_added(self) -> None:
+        users = [create_user(username=f'manyuser{i}') for i in range(20)]
+        for user in users:
+            add_user_to_all_user_group(user)
+        group = Group.objects.get(name='All Users')
+        for user in users:
+            assert user in group.user_set.all()
+
+    def test_user_groups_query(self) -> None:
+        add_user_to_all_user_group(self.user)
+        groups = self.user.groups.all()
+        group_names = [g.name for g in groups]
+        assert 'All Users' in group_names
+
+    def test_group_user_count_increments(self) -> None:
+        Group.objects.filter(name='All Users').delete()
+        group = Group.objects.create(name='All Users')
+        initial_count = group.user_set.count()
+
+        add_user_to_all_user_group(self.user)
+        group.refresh_from_db()
+
+        assert group.user_set.count() == initial_count + 1
+
+    def test_does_not_create_duplicate_groups(self) -> None:
+        Group.objects.filter(name='All Users').delete()
+        user1 = create_user(username='user1')
+        user2 = create_user(username='user2')
+
+        add_user_to_all_user_group(user1)
+        add_user_to_all_user_group(user2)
+
+        assert Group.objects.filter(name='All Users').count() == 1