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

django_spire/auth/permissions/tests/test_decorators.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import pytest
+
+from typing import TYPE_CHECKING
+
+from django.core.exceptions import PermissionDenied
+from django.test import RequestFactory
+
+from django_spire.auth.permissions.decorators import (
+    permission_required,
+    permission_required_decorator_function,
+)
+from django_spire.auth.user.tests.factories import create_super_user, create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
+
+class PermissionRequiredDecoratorFunctionTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+        self.user = create_user(username='testuser')
+        self.user.set_password('password')
+        self.user.save()
+
+    def test_unauthenticated_user_redirects(self) -> None:
+        request = self.factory.get('/test/')
+        request.user = type('AnonymousUser', (), {'is_authenticated': False})()
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        response = permission_required_decorator_function(
+            'some.permission',
+            dummy_view,
+            request
+        )
+        assert response.status_code == 302
+
+    def test_user_without_permission_raises_denied(self) -> None:
+        request = self.factory.get('/test/')
+        request.user = self.user
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        with pytest.raises(PermissionDenied):
+            permission_required_decorator_function(
+                'some.nonexistent_permission',
+                dummy_view,
+                request
+            )
+
+    def test_superuser_has_all_permissions(self) -> None:
+        superuser = create_super_user()
+        request = self.factory.get('/test/')
+        request.user = superuser
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        result = permission_required_decorator_function(
+            'any.permission',
+            dummy_view,
+            request
+        )
+        assert result == 'success'
+
+    def test_redirects_to_login(self) -> None:
+        request = self.factory.get('/test/')
+        request.user = type('AnonymousUser', (), {'is_authenticated': False})()
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        response = permission_required_decorator_function(
+            'some.permission',
+            dummy_view,
+            request
+        )
+        assert 'login' in response.url.lower()
+
+    def test_multiple_permissions_all_required(self) -> None:
+        request = self.factory.get('/test/')
+        request.user = self.user
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        with pytest.raises(PermissionDenied):
+            permission_required_decorator_function(
+                ['perm1', 'perm2'],
+                dummy_view,
+                request,
+                all_required=True
+            )
+
+    def test_multiple_permissions_any_required(self) -> None:
+        superuser = create_super_user()
+        request = self.factory.get('/test/')
+        request.user = superuser
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        result = permission_required_decorator_function(
+            ['perm1', 'perm2'],
+            dummy_view,
+            request,
+            all_required=False
+        )
+        assert result == 'success'
+
+    def test_passes_args_to_view(self) -> None:
+        superuser = create_super_user()
+        request = self.factory.get('/test/')
+        request.user = superuser
+
+        def dummy_view(_request: WSGIRequest, arg1: str, arg2: str) -> str:
+            return f'{arg1}-{arg2}'
+
+        result = permission_required_decorator_function(
+            'any.permission',
+            dummy_view,
+            request,
+            'hello',
+            'world'
+        )
+        assert result == 'hello-world'
+
+    def test_passes_kwargs_to_view(self) -> None:
+        superuser = create_super_user()
+        request = self.factory.get('/test/')
+        request.user = superuser
+
+        def dummy_view(_request: WSGIRequest, **kwargs) -> str:
+            return kwargs.get('key', 'default')
+
+        result = permission_required_decorator_function(
+            'any.permission',
+            dummy_view,
+            request,
+            key='value'
+        )
+        assert result == 'value'
+
+    def test_single_permission_as_string(self) -> None:
+        superuser = create_super_user()
+        request = self.factory.get('/test/')
+        request.user = superuser
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        result = permission_required_decorator_function(
+            'single.permission',
+            dummy_view,
+            request
+        )
+        assert result == 'success'
+
+    def test_empty_permissions_list(self) -> None:
+        request = self.factory.get('/test/')
+        request.user = self.user
+
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        result = permission_required_decorator_function(
+            [],
+            dummy_view,
+            request
+        )
+        assert result == 'success'
+
+
+class PermissionRequiredDecoratorTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+        self.user = create_user(username='testuser')
+        self.user.set_password('password')
+        self.user.save()
+
+    def test_decorator_without_permission(self) -> None:
+        @permission_required('django_spire_auth_group.delete_authgroup')
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = self.user
+
+        with pytest.raises(PermissionDenied):
+            dummy_view(request)
+
+    def test_decorator_superuser_succeeds(self) -> None:
+        superuser = create_super_user()
+
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = superuser
+        result = dummy_view(request)
+        assert result == 'success'
+
+    def test_decorator_multiple_permissions_all_required_fails(self) -> None:
+        @permission_required(
+            'django_spire_auth_group.view_authgroup',
+            'django_spire_auth_group.change_authgroup',
+            all_required=True
+        )
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = self.user
+
+        with pytest.raises(PermissionDenied):
+            dummy_view(request)
+
+    def test_decorator_preserves_function_name(self) -> None:
+        @permission_required('any.permission')
+        def my_special_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        assert my_special_view.__name__ == 'my_special_view'
+
+    def test_decorator_with_args(self) -> None:
+        superuser = create_super_user()
+
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest, arg1: str, arg2: str) -> str:
+            return f'{arg1}-{arg2}'
+
+        request = self.factory.get('/test/')
+        request.user = superuser
+        result = dummy_view(request, 'hello', 'world')
+        assert result == 'hello-world'
+
+    def test_decorator_with_kwargs(self) -> None:
+        superuser = create_super_user()
+
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest, **kwargs) -> str:
+            return kwargs.get('key', 'default')
+
+        request = self.factory.get('/test/')
+        request.user = superuser
+        result = dummy_view(request, key='value')
+        assert result == 'value'
+
+    def test_decorator_multiple_permissions_any_required_superuser(self) -> None:
+        superuser = create_super_user()
+
+        @permission_required('perm1', 'perm2', all_required=False)
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = superuser
+        result = dummy_view(request)
+        assert result == 'success'
+
+    def test_decorator_empty_permissions(self) -> None:
+        @permission_required()
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = self.user
+        result = dummy_view(request)
+        assert result == 'success'
+
+    def test_decorator_unauthenticated_redirects(self) -> None:
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = type('AnonymousUser', (), {'is_authenticated': False})()
+
+        response = dummy_view(request)
+        assert response.status_code == 302
+
+    def test_decorator_view_returns_none(self) -> None:
+        superuser = create_super_user()
+
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest) -> None:
+            return None
+
+        request = self.factory.get('/test/')
+        request.user = superuser
+        result = dummy_view(request)
+        assert result is None
+
+    def test_decorator_view_returns_dict(self) -> None:
+        superuser = create_super_user()
+
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest) -> dict:
+            return {'key': 'value'}
+
+        request = self.factory.get('/test/')
+        request.user = superuser
+        result = dummy_view(request)
+        assert result == {'key': 'value'}
+
+    def test_decorator_single_permission_denied(self) -> None:
+        @permission_required('nonexistent.permission')
+        def dummy_view(_request: WSGIRequest) -> str:
+            return 'success'
+
+        request = self.factory.get('/test/')
+        request.user = self.user
+
+        with pytest.raises(PermissionDenied):
+            dummy_view(request)
+
+    def test_decorator_callable_preserves_docstring(self) -> None:
+        @permission_required('any.permission')
+        def dummy_view(_request: WSGIRequest) -> str:
+            """A docstring."""
+            return 'success'
+
+        assert dummy_view.__doc__ == 'A docstring.'

django_spire/auth/permissions/tests/test_permissions.py

@@ -0,0 +1,337 @@
+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.permissions.permissions import (
+    GroupPermissions,
+    ModelPermission,
+    ModelPermissions,
+    UserPermissionHelper,
+)
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class ModelPermissionTestCase(BaseTestCase):
+    def test_model_permission_attributes(self) -> None:
+        mp = ModelPermission(
+            name='test',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True,
+            verbose_name='Test Permission'
+        )
+        assert mp.name == 'test'
+        assert mp.model_class_path == 'django_spire.auth.group.models.AuthGroup'
+        assert mp.is_proxy_model
+        assert mp.verbose_name == 'Test Permission'
+
+    def test_model_class_property(self) -> None:
+        mp = ModelPermission(
+            name='group',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True
+        )
+        assert mp.model_class == AuthGroup
+
+    def test_model_permission_without_verbose_name(self) -> None:
+        mp = ModelPermission(
+            name='test',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True
+        )
+        assert mp.verbose_name is None
+
+    def test_model_permission_non_proxy(self) -> None:
+        mp = ModelPermission(
+            name='test',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=False
+        )
+        assert not mp.is_proxy_model
+
+    def test_model_permission_name_case_preserved(self) -> None:
+        mp = ModelPermission(
+            name='TestName',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True
+        )
+        assert mp.name == 'TestName'
+
+    def test_model_permission_verbose_name_unicode(self) -> None:
+        mp = ModelPermission(
+            name='test',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True,
+            verbose_name='Tëst Përmission'
+        )
+        assert mp.verbose_name == 'Tëst Përmission'
+
+
+class ModelPermissionsTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.model_permission = ModelPermission(
+            name='group',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True
+        )
+        self.model_permissions = ModelPermissions(self.model_permission)
+
+    def test_app_label(self) -> None:
+        assert self.model_permissions.app_label == 'django_spire_auth_group'
+
+    def test_model_name(self) -> None:
+        assert self.model_permissions.model_name == 'authgroup'
+
+    def test_permissions_queryset(self) -> None:
+        assert self.model_permissions.permissions.count() > 0
+
+    def test_find_permissions_by_level_none(self) -> None:
+        perms = self.model_permissions.find_permissions_by_level(0)
+        assert len(perms) == 0
+
+    def test_find_permissions_by_level_view(self) -> None:
+        perms = self.model_permissions.find_permissions_by_level(1)
+        codenames = [p.codename for p in perms]
+        assert 'view_authgroup' in codenames
+
+    def test_find_permissions_by_level_add(self) -> None:
+        perms = self.model_permissions.find_permissions_by_level(2)
+        codenames = [p.codename for p in perms]
+        assert 'view_authgroup' in codenames
+        assert 'add_authgroup' in codenames
+
+    def test_find_permissions_by_level_change(self) -> None:
+        perms = self.model_permissions.find_permissions_by_level(3)
+        codenames = [p.codename for p in perms]
+        assert 'view_authgroup' in codenames
+        assert 'add_authgroup' in codenames
+        assert 'change_authgroup' in codenames
+
+    def test_find_permissions_by_level_delete(self) -> None:
+        perms = self.model_permissions.find_permissions_by_level(4)
+        codenames = [p.codename for p in perms]
+        assert 'view_authgroup' in codenames
+        assert 'add_authgroup' in codenames
+        assert 'change_authgroup' in codenames
+        assert 'delete_authgroup' in codenames
+
+    def test_special_role_list(self) -> None:
+        roles = self.model_permissions.special_role_list()
+        for role in roles:
+            assert role.codename.startswith('can')
+
+    def test_get_special_role_not_found(self) -> None:
+        result = self.model_permissions.get_special_role('nonexistent_role')
+        assert result is None
+
+    def test_permissions_returns_queryset(self) -> None:
+        assert hasattr(self.model_permissions.permissions, 'filter')
+
+    def test_model_attribute(self) -> None:
+        assert self.model_permissions.model == AuthGroup
+
+    def test_is_proxy_model_attribute(self) -> None:
+        assert self.model_permissions.is_proxy_model
+
+    def test_find_permissions_by_level_returns_list(self) -> None:
+        perms = self.model_permissions.find_permissions_by_level(2)
+        assert isinstance(perms, list)
+
+    def test_special_role_list_returns_list(self) -> None:
+        roles = self.model_permissions.special_role_list()
+        assert isinstance(roles, list)
+
+
+class GroupPermissionsTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.group = AuthGroup.objects.create(name='Test Group')
+        self.model_permission = ModelPermission(
+            name='group',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True
+        )
+        self.group_permissions = GroupPermissions(self.group, self.model_permission)
+
+    def test_initial_perm_level_is_zero(self) -> None:
+        assert self.group_permissions.perm_level() == 0
+
+    def test_perm_level_verbose_none(self) -> None:
+        assert self.group_permissions.perm_level_verbose() == 'None'
+
+    def test_update_perms_to_view(self) -> None:
+        self.group_permissions.update_perms(1)
+        assert self.group_permissions.perm_level() == 1
+        assert self.group_permissions.perm_level_verbose() == 'View'
+
+    def test_update_perms_to_add(self) -> None:
+        self.group_permissions.update_perms(2)
+        assert self.group_permissions.perm_level() == 2
+        assert self.group_permissions.perm_level_verbose() == 'Add'
+
+    def test_update_perms_to_change(self) -> None:
+        self.group_permissions.update_perms(3)
+        assert self.group_permissions.perm_level() == 3
+        assert self.group_permissions.perm_level_verbose() == 'Change'
+
+    def test_update_perms_to_delete(self) -> None:
+        self.group_permissions.update_perms(4)
+        assert self.group_permissions.perm_level() == 4
+        assert self.group_permissions.perm_level_verbose() == 'Delete'
+
+    def test_update_perms_downgrades(self) -> None:
+        self.group_permissions.update_perms(4)
+        self.group_permissions.update_perms(1)
+        assert self.group_permissions.perm_level() == 1
+
+    def test_update_perms_to_none(self) -> None:
+        self.group_permissions.update_perms(4)
+        self.group_permissions.update_perms(0)
+        assert self.group_permissions.perm_level() == 0
+
+    def test_remove_special_permissions(self) -> None:
+        content_type = ContentType.objects.get_for_model(AuthGroup)
+        perms = Permission.objects.filter(content_type=content_type)
+        filtered = GroupPermissions.remove_special_permissions(perms)
+        for perm in filtered:
+            assert not perm.codename.startswith('can')
+
+    def test_set_group_perms_updates(self) -> None:
+        self.group_permissions.update_perms(2)
+        self.group_permissions.set_group_perms()
+        assert self.group_permissions.perm_level() == 2
+
+    def test_has_special_role_false(self) -> None:
+        assert not self.group_permissions.has_special_role('nonexistent')
+
+    def test_group_attribute(self) -> None:
+        assert self.group_permissions.group == self.group
+
+    def test_model_permissions_attribute(self) -> None:
+        assert self.group_permissions.model_permissions is not None
+
+    def test_group_perms_attribute(self) -> None:
+        assert self.group_permissions.group_perms is not None
+
+    def test_update_perms_multiple_times(self) -> None:
+        for level in [1, 2, 3, 4, 3, 2, 1, 0]:
+            self.group_permissions.update_perms(level)
+            assert self.group_permissions.perm_level() == level
+
+    def test_perm_level_returns_int(self) -> None:
+        level = self.group_permissions.perm_level()
+        assert isinstance(level, int)
+
+    def test_perm_level_verbose_returns_str(self) -> None:
+        verbose = self.group_permissions.perm_level_verbose()
+        assert isinstance(verbose, str)
+
+    def test_remove_special_permissions_with_list(self) -> None:
+        content_type = ContentType.objects.get_for_model(AuthGroup)
+        perms = list(Permission.objects.filter(content_type=content_type))
+        filtered = GroupPermissions.remove_special_permissions(perms)
+        assert isinstance(filtered, list)
+
+
+class UserPermissionHelperTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.user = create_user(username='testuser')
+        self.group = AuthGroup.objects.create(name='Test Group')
+        self.model_permission = ModelPermission(
+            name='group',
+            model_class_path='django_spire.auth.group.models.AuthGroup',
+            is_proxy_model=True
+        )
+
+    def test_initial_perm_level_is_zero(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level() == 0
+
+    def test_perm_level_verbose_none(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level_verbose() == 'None'
+
+    def test_user_inherits_group_permissions(self) -> None:
+        self.user.groups.add(self.group)
+        group_perms = GroupPermissions(self.group, self.model_permission)
+        group_perms.update_perms(3)
+
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level() == 3
+        assert helper.perm_level_verbose() == 'Change'
+
+    def test_user_inherits_highest_permission(self) -> None:
+        group2 = AuthGroup.objects.create(name='Group 2')
+        self.user.groups.add(self.group, group2)
+
+        group_perms1 = GroupPermissions(self.group, self.model_permission)
+        group_perms1.update_perms(1)
+
+        group_perms2 = GroupPermissions(group2, self.model_permission)
+        group_perms2.update_perms(4)
+
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level() == 4
+
+    def test_user_no_groups_no_permissions(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level() == 0
+
+    def test_get_user_perms_returns_queryset(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        perms = helper.get_user_perms()
+        assert perms is not None
+
+    def test_user_attribute(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.user == self.user
+
+    def test_model_permissions_attribute(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.model_permissions is not None
+
+    def test_user_perms_attribute(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.user_perms is not None
+
+    def test_perm_level_returns_int(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        level = helper.perm_level()
+        assert isinstance(level, int)
+
+    def test_perm_level_verbose_returns_str(self) -> None:
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        verbose = helper.perm_level_verbose()
+        assert isinstance(verbose, str)
+
+    def test_user_removed_from_group_loses_permissions(self) -> None:
+        self.user.groups.add(self.group)
+        group_perms = GroupPermissions(self.group, self.model_permission)
+        group_perms.update_perms(3)
+
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level() == 3
+
+        self.user.groups.remove(self.group)
+        helper2 = UserPermissionHelper(self.user, self.model_permission)
+        assert helper2.perm_level() == 0
+
+    def test_multiple_groups_same_permission_level(self) -> None:
+        group2 = AuthGroup.objects.create(name='Group 2')
+        self.user.groups.add(self.group, group2)
+
+        group_perms1 = GroupPermissions(self.group, self.model_permission)
+        group_perms1.update_perms(2)
+
+        group_perms2 = GroupPermissions(group2, self.model_permission)
+        group_perms2.update_perms(2)
+
+        helper = UserPermissionHelper(self.user, self.model_permission)
+        assert helper.perm_level() == 2