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

django_spire/auth/views/redirect_views.py

@@ -1,27 +1,32 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from django.conf import settings
 from django.contrib.auth import logout
 from django.contrib.auth.decorators import login_required
 from django.http import HttpResponseRedirect
 from django.urls import reverse
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 @login_required()
-def login_redirect_view(request, **kwargs):
+def login_redirect_view(request: WSGIRequest, **kwargs):
     if not request.user.is_authenticated:
         return HttpResponseRedirect(reverse('django_spire:auth:admin:login'))
-    else:
-        # MFA implementation if required
-        # profile = request.user.profile
-        #
-        # if profile.requires_mfa():
-        #     return HttpResponseRedirect(reverse('django_spire:auth:mfa:redirect:notification'))
 
-        return HttpResponseRedirect(reverse(settings.LOGIN_REDIRECT_SUCCESS_URL))
+    # MFA implementation if required
+    # profile = request.user.profile
+    #
+    # if profile.requires_mfa():
+    #     return HttpResponseRedirect(reverse('django_spire:auth:mfa:redirect:notification'))
+
+    return HttpResponseRedirect(reverse(settings.LOGIN_REDIRECT_SUCCESS_URL))
 
 
 @login_required()
-def logout_redirect_view(request, **kwargs):
+def logout_redirect_view(request: WSGIRequest, **kwargs):
     logout(request)
     return HttpResponseRedirect(reverse('django_spire:auth:admin:login'))

django_spire/comment/admin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib import admin
 from django.urls import reverse
 from django.utils.html import format_html

django_spire/comment/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/comment/templatetags/comment_tags.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from django import template
 
+
 register = template.Library()
 
 

django_spire/comment/tests/test_forms.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from django.contrib.contenttypes.models import ContentType
+
+from django_spire.comment.forms import CommentForm
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestCommentForm(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.content_type = ContentType.objects.get_for_model(self.super_user)
+
+    def test_valid_form(self) -> None:
+        form = CommentForm(data={'information': 'Test comment'})
+        assert form.is_valid() is True
+
+    def test_form_save(self) -> None:
+        form = CommentForm(data={'information': 'New comment'})
+        assert form.is_valid() is True
+        comment = form.save(commit=False)
+        comment.content_type = self.content_type
+        comment.object_id = self.super_user.pk
+        comment.user = self.super_user
+        comment.save()
+        assert comment.information == 'New comment'

django_spire/comment/tests/test_models.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from django.contrib.contenttypes.models import ContentType
+
+from django_spire.comment.models import Comment
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestCommentModel(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.content_type = ContentType.objects.get_for_model(self.super_user)
+        self.comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='This is a test comment.'
+        )
+
+    def test_str(self) -> None:
+        assert str(self.comment) == 'This is a ...'
+
+    def test_str_short_information(self) -> None:
+        comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Short'
+        )
+        assert str(comment) == 'Short...'
+
+    def test_scrape_username_list(self) -> None:
+        comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Hello @john_doe and @jane_doe'
+        )
+        usernames = comment.scrape_username_list()
+        assert usernames == ['john_doe', 'jane_doe']
+
+    def test_scrape_username_list_empty(self) -> None:
+        usernames = self.comment.scrape_username_list()
+        assert usernames == []
+
+    def test_scrape_username_list_single(self) -> None:
+        comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Hello @stratus'
+        )
+        usernames = comment.scrape_username_list()
+        assert usernames == ['stratus']
+
+    def test_find_user_list(self) -> None:
+        comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Hello @stratus'
+        )
+        users = comment.find_user_list()
+        assert self.super_user in users
+
+    def test_find_user_list_empty(self) -> None:
+        users = self.comment.find_user_list()
+        assert users.count() == 0
+
+    def test_update(self) -> None:
+        self.comment.update('Updated information')
+        self.comment.refresh_from_db()
+        assert self.comment.information == 'Updated information'
+        assert self.comment.is_edited is True
+
+    def test_update_sets_is_edited(self) -> None:
+        assert self.comment.is_edited is False
+        self.comment.update('New content')
+        assert self.comment.is_edited is True
+
+    def test_parent_relationship(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent comment'
+        )
+        child_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child comment'
+        )
+        assert child_comment.parent == parent_comment
+        assert child_comment in parent_comment.children.all()
+
+    def test_default_ordering(self) -> None:
+        comment1 = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='First'
+        )
+
+        comment2 = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Second'
+        )
+
+        comments = list(Comment.objects.order_by('-pk')[:2])
+        assert comments == [comment2, comment1]
+
+
+class TestCommentRelationships(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.content_type = ContentType.objects.get_for_model(self.super_user)
+        self.comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Test comment'
+        )
+
+    def test_comment_user_relationship(self) -> None:
+        assert self.comment.user == self.super_user
+        assert self.comment in self.super_user.comment_list.all()
+
+    def test_comment_content_object(self) -> None:
+        assert self.comment.content_object == self.super_user
+        assert self.comment.object_id == self.super_user.pk
+
+    def test_nested_replies(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent'
+        )
+        child1 = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child 1'
+        )
+        child2 = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child 2'
+        )
+        assert parent_comment.children.count() == 2
+        assert child1 in parent_comment.children.all()
+        assert child2 in parent_comment.children.all()
+
+    def test_cascade_delete_parent(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent'
+        )
+        child_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child'
+        )
+        child_pk = child_comment.pk
+        parent_comment.delete()
+        assert Comment.objects.filter(pk=child_pk).exists() is False
+
+
+class TestCommentDefaults(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.content_type = ContentType.objects.get_for_model(self.super_user)
+        self.comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Test comment'
+        )
+
+    def test_default_is_active(self) -> None:
+        assert self.comment.is_active is True
+
+    def test_default_is_deleted(self) -> None:
+        assert self.comment.is_deleted is False
+
+    def test_default_is_edited(self) -> None:
+        assert self.comment.is_edited is False
+
+    def test_default_information(self) -> None:
+        comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user
+        )
+        assert comment.information == ''
+
+    def test_created_datetime_auto_set(self) -> None:
+        assert self.comment.created_datetime is not None
+
+    def test_parent_default_null(self) -> None:
+        assert self.comment.parent is None

django_spire/comment/tests/test_querysets.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from django.contrib.contenttypes.models import ContentType
+
+from django_spire.comment.models import Comment
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestCommentQuerySet(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.content_type = ContentType.objects.get_for_model(self.super_user)
+        self.comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Test comment'
+        )
+
+    def test_active(self) -> None:
+        comments = Comment.objects.active()
+        assert self.comment in comments
+
+    def test_active_excludes_deleted(self) -> None:
+        comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Deleted comment',
+            is_deleted=True
+        )
+        comments = Comment.objects.active()
+        assert comment not in comments
+
+    def test_top_level(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent'
+        )
+        child_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child'
+        )
+        top_level = Comment.objects.top_level()
+        assert parent_comment in top_level
+        assert child_comment not in top_level
+
+    def test_prefetch_user(self) -> None:
+        comments = Comment.objects.prefetch_user()
+        assert self.comment in comments
+
+    def test_prefetch_parent(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent'
+        )
+        child_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child'
+        )
+        comments = Comment.objects.prefetch_parent()
+        assert child_comment in comments
+
+    def test_prefetch_replies(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent'
+        )
+        comments = Comment.objects.prefetch_replies()
+        assert parent_comment in comments
+
+    def test_chained_querysets(self) -> None:
+        parent_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            information='Parent'
+        )
+        child_comment = Comment.objects.create(
+            content_type=self.content_type,
+            object_id=self.super_user.pk,
+            user=self.super_user,
+            parent=parent_comment,
+            information='Child'
+        )
+        comments = Comment.objects.active().top_level().prefetch_user()
+        assert parent_comment in comments
+        assert child_comment not in comments

django_spire/comment/tests/test_utils.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import Group, Permission
+from django.contrib.contenttypes.models import ContentType
+
+from django_spire.auth.user.models import AuthUser
+from django_spire.comment.models import Comment
+from django_spire.comment.utils import (
+    find_user_list_from_content_type,
+    generate_comment_user_list_data,
+    parse_user_id_to_int_list,
+)
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestGenerateCommentUserListData(BaseTestCase):
+    def test_single_user(self) -> None:
+        self.super_user.first_name = 'Test'
+        self.super_user.last_name = 'User'
+        self.super_user.save()
+        user_list = [self.super_user]
+        data = generate_comment_user_list_data(user_list)
+        assert len(data) == 1
+        assert data[0]['full_name'] == 'Test_User'
+        assert data[0]['id'] == self.super_user.pk
+
+    def test_empty_list(self) -> None:
+        data = generate_comment_user_list_data([])
+        assert data == []
+
+    def test_multiple_users(self) -> None:
+        self.super_user.first_name = 'Test'
+        self.super_user.last_name = 'User'
+        self.super_user.save()
+        other_user = AuthUser.objects.create_user(
+            username='other',
+            first_name='Other',
+            last_name='User'
+        )
+        user_list = [self.super_user, other_user]
+        data = generate_comment_user_list_data(user_list)
+        assert len(data) == 2
+        full_names = [d['full_name'] for d in data]
+        assert 'Test_User' in full_names
+        assert 'Other_User' in full_names
+
+
+class TestParseUserIdToIntList(BaseTestCase):
+    def test_multiple_ids(self) -> None:
+        other_user = AuthUser.objects.create_user(username='other')
+        user_id_str = f'{self.super_user.pk},{other_user.pk}'
+        users = parse_user_id_to_int_list(user_id_str)
+        assert self.super_user in users
+        assert other_user in users
+
+    def test_single_id(self) -> None:
+        user_id_str = str(self.super_user.pk)
+        users = parse_user_id_to_int_list(user_id_str)
+        assert self.super_user in users
+        assert users.count() == 1
+
+
+class TestFindUserListFromContentType(BaseTestCase):
+    def test_find_users_with_permission(self) -> None:
+        content_type = ContentType.objects.get_for_model(Comment)
+        permission = Permission.objects.get(
+            content_type=content_type,
+            codename='view_comment'
+        )
+        group = Group.objects.create(name='test_group')
+        group.permissions.add(permission)
+        self.super_user.groups.add(group)
+
+        users = find_user_list_from_content_type('django_spire_comment', 'comment')
+        assert self.super_user in users
+
+    def test_excludes_users_without_permission(self) -> None:
+        other_user = AuthUser.objects.create_user(username='other')
+        content_type = ContentType.objects.get_for_model(Comment)
+        permission = Permission.objects.get(
+            content_type=content_type,
+            codename='view_comment'
+        )
+        group = Group.objects.create(name='test_group')
+        group.permissions.add(permission)
+        self.super_user.groups.add(group)
+
+        users = find_user_list_from_content_type('django_spire_comment', 'comment')
+        assert self.super_user in users
+        assert other_user not in users

django_spire/comment/urls.py

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

django_spire/comment/utils.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
 
-def find_user_list_from_content_type(app_label, model_name):
-    from django.contrib.contenttypes.models import ContentType
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from django.db.models import Model, QuerySet
+
+
+def find_user_list_from_content_type(app_label: str, model_name: str) -> QuerySet[User]:
     from django.contrib.auth.models import Permission, Group, User
+    from django.contrib.contenttypes.models import ContentType
 
     content_type = ContentType.objects.get(app_label=app_label, model=model_name)
     permission = Permission.objects.get(content_type=content_type, codename=f'view_{model_name}')
@@ -12,28 +18,31 @@ def find_user_list_from_content_type(app_label, model_name):
     return User.objects.filter(groups__in=groups).distinct()
 
 
-def generate_comment_user_list_data(user_list):
-    user_data = []
-
-    for user in user_list:
-        user_data.append({
+def generate_comment_user_list_data(user_list: QuerySet[User] | list[User]) -> list[dict]:
+    return [
+        {
             'full_name': user.get_full_name().replace(' ', '_'),
             'id': user.pk,
-        })
-
-    return user_data
+        }
+        for user in user_list
+    ]
 
 
-def parse_user_id_to_int_list(user_id_str):
+def parse_user_id_to_int_list(user_id_str: str) -> QuerySet[User]:
     from django.contrib.auth.models import User
 
     user_id_list =  [int(user_id) for user_id in user_id_str.split(',')]
     return User.objects.filter(id__in=user_id_list)
 
 
-def process_comment_notifications(user_list, comment_information, related_obj, user_commenting):
-    from django_spire.notification.models import Notification
+def process_comment_notifications(
+    user_list: QuerySet[User] | list[User],
+    comment_information: str,
+    related_obj: Model,
+    user_commenting: User
+) -> None:
     from django.contrib.sites.models import Site
+    from django_spire.notification.models import Notification
 
     for user in user_list:
         if user != user_commenting:

django_spire/comment/views.py

@@ -78,7 +78,7 @@ def comment_form_view(
     if request.method == 'POST':
         form = CommentForm(request.POST, instance=comment)
         if form.is_valid():
-            # Todo: Create comment factory.
+            # TODO: Create comment factory.
             if comment_pk == 0:
                 obj.add_comment(
                     user=request.user,

django_spire/conf.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.conf import settings as django_settings
 
 from django_spire import settings as django_spire_default_settings
@@ -14,12 +16,11 @@ class Settings:
         if hasattr(django_spire_default_settings, name):
             django_spire_value = getattr(django_spire_default_settings, name)
 
-        if name == 'DJANGO_SPIRE_AUTH_CONTROLLERS':
-            if isinstance(django_value, dict) and isinstance(django_spire_value, dict):
-                return {
-                    **django_spire_value,
-                    **django_value
-                }
+        if name == 'DJANGO_SPIRE_AUTH_CONTROLLERS' and isinstance(django_value, dict) and isinstance(django_spire_value, dict):
+            return {
+                **django_spire_value,
+                **django_value
+            }
 
         if django_value is not None:
             return django_value
@@ -29,4 +30,5 @@ class Settings:
 
         return None
 
+
 settings = Settings()

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.23.6'
+__VERSION__ = '0.23.8'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/contrib/breadcrumb/apps.py

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