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

django_spire/auth/group/tests/test_forms.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+from django_spire.auth.group.forms import GroupForm, GroupNamesForm, GroupUserForm
+from django_spire.auth.group.models import AuthGroup
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class GroupFormTestCase(BaseTestCase):
+    def test_valid_form(self) -> None:
+        form = GroupForm(data={'name': 'Test Group'})
+        assert form.is_valid()
+
+    def test_reserved_name_all_users(self) -> None:
+        form = GroupForm(data={'name': 'All Users'})
+        assert not form.is_valid()
+        assert 'name' in form.errors
+
+    def test_reserved_name_all_users_case_insensitive(self) -> None:
+        form = GroupForm(data={'name': 'all users'})
+        assert not form.is_valid()
+        assert 'name' in form.errors
+
+    def test_reserved_name_all_users_mixed_case(self) -> None:
+        form = GroupForm(data={'name': 'ALL USERS'})
+        assert not form.is_valid()
+        assert 'name' in form.errors
+
+    def test_reserved_name_all_users_with_extra_spaces(self) -> None:
+        form = GroupForm(data={'name': 'All  Users'})
+        assert form.is_valid()
+
+    def test_empty_name(self) -> None:
+        form = GroupForm(data={'name': ''})
+        assert not form.is_valid()
+
+    def test_whitespace_only_name(self) -> None:
+        form = GroupForm(data={'name': '   '})
+        assert not form.is_valid()
+
+    def test_save_creates_group(self) -> None:
+        form = GroupForm(data={'name': 'New Group'})
+        assert form.is_valid()
+        group = form.save()
+        assert group.name == 'New Group'
+        assert AuthGroup.objects.filter(name='New Group').exists()
+
+    def test_save_updates_existing_group(self) -> None:
+        group = AuthGroup.objects.create(name='Original Name')
+        form = GroupForm(data={'name': 'Updated Name'}, instance=group)
+        assert form.is_valid()
+        updated_group = form.save()
+        assert updated_group.pk == group.pk
+        assert updated_group.name == 'Updated Name'
+
+    def test_name_with_special_characters(self) -> None:
+        form = GroupForm(data={'name': 'Test & Group <Special>'})
+        assert form.is_valid()
+
+    def test_name_with_unicode(self) -> None:
+        form = GroupForm(data={'name': 'Tëst Grøup 日本語'})
+        assert form.is_valid()
+
+    def test_name_max_length(self) -> None:
+        long_name = 'A' * 150
+        form = GroupForm(data={'name': long_name})
+        assert form.is_valid()
+
+    def test_name_exceeds_max_length(self) -> None:
+        long_name = 'A' * 151
+        form = GroupForm(data={'name': long_name})
+        assert not form.is_valid()
+
+    def test_duplicate_name_fails(self) -> None:
+        AuthGroup.objects.create(name='Existing Group')
+        form = GroupForm(data={'name': 'Existing Group'})
+        assert not form.is_valid()
+
+    def test_duplicate_name_case_sensitive(self) -> None:
+        AuthGroup.objects.create(name='Existing Group')
+        form = GroupForm(data={'name': 'existing group'})
+        assert form.is_valid()
+
+    def test_reserved_name_error_message(self) -> None:
+        form = GroupForm(data={'name': 'All Users'})
+        form.is_valid()
+        assert 'reserved' in form.errors['name'][0].lower()
+
+    def test_form_excludes_permissions_field(self) -> None:
+        form = GroupForm()
+        assert 'permissions' not in form.fields
+
+    def test_update_to_reserved_name_fails(self) -> None:
+        group = AuthGroup.objects.create(name='Original')
+        form = GroupForm(data={'name': 'All Users'}, instance=group)
+        assert not form.is_valid()
+
+    def test_name_with_leading_trailing_whitespace(self) -> None:
+        form = GroupForm(data={'name': '  Test Group  '})
+        assert form.is_valid()
+
+    def test_name_with_newline(self) -> None:
+        form = GroupForm(data={'name': 'Test\nGroup'})
+        assert form.is_valid()
+
+    def test_name_with_tab(self) -> None:
+        form = GroupForm(data={'name': 'Test\tGroup'})
+        assert form.is_valid()
+
+    def test_numeric_name(self) -> None:
+        form = GroupForm(data={'name': '12345'})
+        assert form.is_valid()
+
+
+class GroupNamesFormTestCase(BaseTestCase):
+    def test_valid_json_groups(self) -> None:
+        form = GroupNamesForm(data={'groups': '["Group A", "Group B"]'})
+        assert form.is_valid()
+        assert form.cleaned_data['groups'] == ['Group A', 'Group B']
+
+    def test_empty_groups(self) -> None:
+        form = GroupNamesForm(data={'groups': '[]'})
+        assert form.is_valid()
+        assert form.cleaned_data['groups'] == []
+
+    def test_save_creates_groups(self) -> None:
+        form = GroupNamesForm(data={'groups': '["Test A", "Test B"]'})
+        assert form.is_valid()
+        groups = form.save()
+        assert len(groups) == 2
+
+    def test_single_group(self) -> None:
+        form = GroupNamesForm(data={'groups': '["Single Group"]'})
+        assert form.is_valid()
+        assert form.cleaned_data['groups'] == ['Single Group']
+
+    def test_groups_with_special_characters(self) -> None:
+        form = GroupNamesForm(data={'groups': '["Group & Co", "Test <Group>"]'})
+        assert form.is_valid()
+        assert len(form.cleaned_data['groups']) == 2
+
+    def test_save_skips_existing_groups(self) -> None:
+        AuthGroup.objects.create(name='Existing')
+        form = GroupNamesForm(data={'groups': '["Existing", "New"]'})
+        assert form.is_valid()
+        groups = form.save()
+        assert len(groups) == 1
+        assert groups[0].name == 'New'
+
+    def test_many_groups(self) -> None:
+        group_names = [f'Group {i}' for i in range(20)]
+        form = GroupNamesForm(data={'groups': str(group_names).replace("'", '"')})
+        assert form.is_valid()
+        assert len(form.cleaned_data['groups']) == 20
+
+    def test_unicode_group_names(self) -> None:
+        form = GroupNamesForm(data={'groups': '["Tëst", "日本語"]'})
+        assert form.is_valid()
+        assert len(form.cleaned_data['groups']) == 2
+
+    def test_empty_string_in_list(self) -> None:
+        form = GroupNamesForm(data={'groups': '["", "Valid"]'})
+        assert form.is_valid()
+        assert '' in form.cleaned_data['groups']
+
+    def test_whitespace_group_names(self) -> None:
+        form = GroupNamesForm(data={'groups': '["  Spaces  ", "Normal"]'})
+        assert form.is_valid()
+
+    def test_nested_json_fails(self) -> None:
+        form = GroupNamesForm(data={'groups': '[["nested"]]'})
+        assert form.is_valid()
+
+    def test_null_in_list(self) -> None:
+        form = GroupNamesForm(data={'groups': '[null, "Valid"]'})
+        assert form.is_valid()
+
+    def test_number_in_list(self) -> None:
+        form = GroupNamesForm(data={'groups': '[123, "Valid"]'})
+        assert form.is_valid()
+
+    def test_duplicate_names_in_list(self) -> None:
+        form = GroupNamesForm(data={'groups': '["Dup", "Dup", "Dup"]'})
+        assert form.is_valid()
+
+    def test_groups_field_not_required(self) -> None:
+        form = GroupNamesForm(data={})
+        assert not form.is_valid()
+
+
+class GroupUserFormTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user1 = create_user(username='user1', first_name='User', last_name='One')
+        self.user2 = create_user(username='user2', first_name='User', last_name='Two')
+        self.user3 = create_user(username='user3', first_name='User', last_name='Three')
+
+    def test_valid_form_with_users(self) -> None:
+        form = GroupUserForm(data={'users': [self.user1.pk, self.user2.pk]})
+        assert form.is_valid()
+
+    def test_valid_form_empty_users(self) -> None:
+        form = GroupUserForm(data={'users': []})
+        assert form.is_valid()
+
+    def test_user_label(self) -> None:
+        label = GroupUserForm.user_label(self.user1)
+        assert label == 'User One'
+
+    def test_single_user(self) -> None:
+        form = GroupUserForm(data={'users': [self.user1.pk]})
+        assert form.is_valid()
+        assert len(form.cleaned_data['users']) == 1
+
+    def test_all_users(self) -> None:
+        form = GroupUserForm(data={'users': [self.user1.pk, self.user2.pk, self.user3.pk]})
+        assert form.is_valid()
+        assert len(form.cleaned_data['users']) == 3
+
+    def test_invalid_user_id(self) -> None:
+        form = GroupUserForm(data={'users': [99999]})
+        assert not form.is_valid()
+
+    def test_inactive_user_excluded_from_queryset(self) -> None:
+        inactive_user = create_user(username='inactive', is_active=False)
+        form = GroupUserForm()
+        user_ids = list(form.fields['users'].queryset.values_list('id', flat=True))
+        assert inactive_user.pk not in user_ids
+
+    def test_user_label_with_empty_names(self) -> None:
+        user = create_user(username='noname', first_name='', last_name='')
+        label = GroupUserForm.user_label(user)
+        assert label == ''
+
+    def test_user_label_first_name_only(self) -> None:
+        user = create_user(username='firstonly', first_name='First', last_name='')
+        label = GroupUserForm.user_label(user)
+        assert 'First' in label
+
+    def test_user_label_last_name_only(self) -> None:
+        user = create_user(username='lastonly', first_name='', last_name='Last')
+        label = GroupUserForm.user_label(user)
+        assert 'Last' in label
+
+    def test_mixed_valid_invalid_user_ids(self) -> None:
+        form = GroupUserForm(data={'users': [self.user1.pk, 99999]})
+        assert not form.is_valid()
+
+    def test_duplicate_user_ids(self) -> None:
+        form = GroupUserForm(data={'users': [self.user1.pk, self.user1.pk]})
+        assert form.is_valid()
+        assert len(form.cleaned_data['users']) == 1
+
+    def test_negative_user_id(self) -> None:
+        form = GroupUserForm(data={'users': [-1]})
+        assert not form.is_valid()
+
+    def test_string_user_id(self) -> None:
+        form = GroupUserForm(data={'users': ['invalid']})
+        assert not form.is_valid()
+
+    def test_queryset_excludes_inactive_users(self) -> None:
+        create_user(username='inactive1', is_active=False)
+        create_user(username='inactive2', is_active=False)
+        form = GroupUserForm()
+        queryset = form.fields['users'].queryset
+        assert not queryset.filter(is_active=False).exists()
+
+    def test_form_users_field_not_required(self) -> None:
+        form = GroupUserForm(data={})
+        assert form.is_valid()
+
+    def test_user_label_with_unicode(self) -> None:
+        user = create_user(username='unicode', first_name='Tëst', last_name='Üsér')
+        label = GroupUserForm.user_label(user)
+        assert 'Tëst' in label
+        assert 'Üsér' in label
+
+    def test_zero_user_id(self) -> None:
+        form = GroupUserForm(data={'users': [0]})
+        assert not form.is_valid()

django_spire/auth/group/tests/test_models.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+
+from django_spire.auth.group.models import AuthGroup
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class AuthGroupModelTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.group = AuthGroup.objects.create(name='Test Group')
+
+    def test_str_representation(self) -> None:
+        assert str(self.group) == 'Test Group'
+
+    def test_str_representation_with_special_characters(self) -> None:
+        group = AuthGroup.objects.create(name='Test & Group <Special>')
+        assert str(group) == 'Test & Group <Special>'
+
+    def test_base_breadcrumb_returns_breadcrumbs(self) -> None:
+        crumbs = AuthGroup.base_breadcrumb()
+        assert crumbs is not None
+
+    def test_breadcrumbs_with_pk_returns_breadcrumbs(self) -> None:
+        crumbs = self.group.breadcrumbs()
+        assert crumbs is not None
+
+    def test_breadcrumbs_without_pk_returns_breadcrumbs(self) -> None:
+        unsaved_group = AuthGroup(name='Unsaved Group')
+        crumbs = unsaved_group.breadcrumbs()
+        assert crumbs is not None
+
+    def test_meta_proxy(self) -> None:
+        assert AuthGroup._meta.proxy
+
+    def test_meta_verbose_name(self) -> None:
+        assert AuthGroup._meta.verbose_name == 'Auth Group'
+        assert AuthGroup._meta.verbose_name_plural == 'Auth Groups'
+
+    def test_group_creation(self) -> None:
+        group = AuthGroup.objects.create(name='New Test Group')
+        assert group.pk is not None
+        assert AuthGroup.objects.filter(pk=group.pk).exists()
+
+    def test_group_update(self) -> None:
+        self.group.name = 'Updated Group Name'
+        self.group.save()
+        self.group.refresh_from_db()
+        assert self.group.name == 'Updated Group Name'
+
+    def test_group_deletion(self) -> None:
+        group_pk = self.group.pk
+        self.group.delete()
+        assert not AuthGroup.objects.filter(pk=group_pk).exists()
+
+    def test_group_user_relationship(self) -> None:
+        user = create_user(username='groupuser')
+        self.group.user_set.add(user)
+        assert user in self.group.user_set.all()
+        assert self.group in user.groups.all()
+
+    def test_group_permissions_relationship(self) -> None:
+        assert hasattr(self.group, 'permissions')
+
+    def test_group_name_max_length(self) -> None:
+        max_length = AuthGroup._meta.get_field('name').max_length
+        assert max_length == 150
+
+    def test_multiple_groups_creation(self) -> None:
+        groups = [
+            AuthGroup.objects.create(name=f'Group {i}')
+            for i in range(5)
+        ]
+        assert len(groups) == 5
+        assert AuthGroup.objects.count() >= 5
+
+    def test_group_queryset_ordering(self) -> None:
+        AuthGroup.objects.create(name='Zebra Group')
+        AuthGroup.objects.create(name='Alpha Group')
+        groups = AuthGroup.objects.all().order_by('name')
+        names = list(groups.values_list('name', flat=True))
+        assert names == sorted(names)
+
+    def test_group_add_multiple_users(self) -> None:
+        user1 = create_user(username='user1')
+        user2 = create_user(username='user2')
+        self.group.user_set.add(user1, user2)
+        assert self.group.user_set.count() == 2
+
+    def test_group_remove_user(self) -> None:
+        user = create_user(username='removeuser')
+        self.group.user_set.add(user)
+        self.group.user_set.remove(user)
+        assert user not in self.group.user_set.all()
+
+    def test_group_clear_users(self) -> None:
+        user1 = create_user(username='clearuser1')
+        user2 = create_user(username='clearuser2')
+        self.group.user_set.add(user1, user2)
+        self.group.user_set.clear()
+        assert self.group.user_set.count() == 0
+
+    def test_group_add_permission(self) -> None:
+        content_type = ContentType.objects.get_for_model(AuthGroup)
+        permission = Permission.objects.filter(content_type=content_type).first()
+        if permission:
+            self.group.permissions.add(permission)
+            assert permission in self.group.permissions.all()
+
+    def test_group_remove_permission(self) -> None:
+        content_type = ContentType.objects.get_for_model(AuthGroup)
+        permission = Permission.objects.filter(content_type=content_type).first()
+        if permission:
+            self.group.permissions.add(permission)
+            self.group.permissions.remove(permission)
+            assert permission not in self.group.permissions.all()
+
+    def test_group_with_unicode_name(self) -> None:
+        group = AuthGroup.objects.create(name='Tëst Grøup 日本語')
+        assert group.name == 'Tëst Grøup 日本語'
+        assert str(group) == 'Tëst Grøup 日本語'
+
+    def test_group_name_with_max_length(self) -> None:
+        long_name = 'A' * 150
+        group = AuthGroup.objects.create(name=long_name)
+        assert group.name == long_name
+
+    def test_breadcrumbs_contains_group_name(self) -> None:
+        crumbs = self.group.breadcrumbs()
+        names = [c['name'] for c in crumbs]
+        assert 'Test Group' in names
+
+    def test_base_breadcrumb_contains_groups(self) -> None:
+        crumbs = AuthGroup.base_breadcrumb()
+        names = [c['name'] for c in crumbs]
+        assert 'Groups' in names
+
+    def test_group_user_set_query(self) -> None:
+        user = create_user(username='queryuser')
+        self.group.user_set.add(user)
+        queried_users = self.group.user_set.filter(username='queryuser')
+        assert queried_users.count() == 1
+
+    def test_group_inheritance_from_django_group(self) -> None:
+        from django.contrib.auth.models import Group
+        assert issubclass(AuthGroup, Group)
+
+    def test_group_activity_mixin(self) -> None:
+        assert hasattr(self.group, 'add_activity')
+
+    def test_group_empty_name_constraint(self) -> None:
+        group = AuthGroup.objects.create(name='')
+        assert group.pk is not None
+
+    def test_group_whitespace_name(self) -> None:
+        group = AuthGroup.objects.create(name='   ')
+        assert group.name == '   '
+
+    def test_group_special_characters_name(self) -> None:
+        special_name = '!@#$%^&*()_+-=[]{}|;:,.<>?'
+        group = AuthGroup.objects.create(name=special_name)
+        assert group.name == special_name
+
+    def test_group_refresh_from_db(self) -> None:
+        original_name = self.group.name
+        AuthGroup.objects.filter(pk=self.group.pk).update(name='Changed Name')
+        self.group.refresh_from_db()
+        assert self.group.name == 'Changed Name'
+        assert self.group.name != original_name
+
+    def test_group_get_or_create(self) -> None:
+        group, created = AuthGroup.objects.get_or_create(name='Get Or Create Group')
+        assert created
+        group2, created2 = AuthGroup.objects.get_or_create(name='Get Or Create Group')
+        assert not created2
+        assert group.pk == group2.pk
+
+    def test_group_bulk_create(self) -> None:
+        groups = AuthGroup.objects.bulk_create([
+            AuthGroup(name='Bulk 1'),
+            AuthGroup(name='Bulk 2'),
+            AuthGroup(name='Bulk 3'),
+        ])
+        assert len(groups) == 3
+
+    def test_group_exists(self) -> None:
+        assert AuthGroup.objects.filter(name='Test Group').exists()
+        assert not AuthGroup.objects.filter(name='Nonexistent Group').exists()

django_spire/auth/group/tests/test_querysets.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from django_spire.auth.group.models import AuthGroup
+from django_spire.auth.group.querysets import GroupQuerySet
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class GroupQuerySetTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.group_c = AuthGroup.objects.create(name='Charlie Group')
+        self.group_a = AuthGroup.objects.create(name='Alpha Group')
+        self.group_b = AuthGroup.objects.create(name='Beta Group')
+
+    def test_active_returns_ordered_by_name(self) -> None:
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        names = list(result.values_list('name', flat=True))
+        assert names == ['Alpha Group', 'Beta Group', 'Charlie Group']
+
+    def test_active_returns_all_groups(self) -> None:
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert result.count() == 3
+
+    def test_active_empty_queryset(self) -> None:
+        AuthGroup.objects.all().delete()
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert result.count() == 0
+
+    def test_active_single_group(self) -> None:
+        AuthGroup.objects.all().delete()
+        AuthGroup.objects.create(name='Single Group')
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert result.count() == 1
+
+    def test_active_ordering_with_numbers(self) -> None:
+        group1 = AuthGroup.objects.create(name='AAA First')
+        group2 = AuthGroup.objects.create(name='BBB Second')
+        group3 = AuthGroup.objects.create(name='CCC Third')
+        queryset = AuthGroup.objects.filter(pk__in=[group1.pk, group2.pk, group3.pk])
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        names = list(result.values_list('name', flat=True))
+        assert names == ['AAA First', 'BBB Second', 'CCC Third']
+
+    def test_active_ordering_with_special_characters(self) -> None:
+        AuthGroup.objects.create(name='!Special')
+        AuthGroup.objects.create(name='@Another')
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert result.count() >= 2
+
+    def test_active_ordering_case_sensitive(self) -> None:
+        AuthGroup.objects.all().delete()
+        AuthGroup.objects.create(name='alpha')
+        AuthGroup.objects.create(name='Alpha')
+        AuthGroup.objects.create(name='ALPHA')
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        names = list(result.values_list('name', flat=True))
+        assert len(names) == 3
+
+    def test_active_ordering_with_unicode(self) -> None:
+        AuthGroup.objects.create(name='Ñame')
+        AuthGroup.objects.create(name='Ääkkönen')
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert result.count() >= 2
+
+    def test_active_is_chainable(self) -> None:
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active().filter(name__contains='Group')
+        assert result.count() == 3
+
+    def test_active_with_prefetch(self) -> None:
+        queryset = AuthGroup.objects.all().prefetch_related('permissions')
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert result.count() == 3
+
+    def test_active_returns_queryset(self) -> None:
+        queryset = AuthGroup.objects.all()
+        queryset.__class__ = GroupQuerySet
+        result = queryset.active()
+        assert hasattr(result, 'filter')
+        assert hasattr(result, 'exclude')