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

django_spire/contrib/pagination/tests/test_pagination.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.core.paginator import Page
+from django.test import RequestFactory, TestCase
+
+from django_spire.contrib.pagination.pagination import paginate_list
+from django_spire.contrib.pagination.templatetags.pagination_tags import (
+    get_elided_page_range,
+    pagination_url,
+)
+
+
+class TestPaginateList(TestCase):
+    def setUp(self) -> None:
+        self.object_list = list(range(100))
+
+    def test_custom_page_number(self) -> None:
+        result = paginate_list(self.object_list, page_number=2)
+
+        assert result.number == 2
+
+    def test_custom_per_page(self) -> None:
+        result = paginate_list(self.object_list, per_page=10)
+
+        assert len(result.object_list) == 10
+
+    def test_default_page_number(self) -> None:
+        result = paginate_list(self.object_list)
+
+        assert result.number == 1
+
+    def test_default_per_page(self) -> None:
+        result = paginate_list(self.object_list)
+
+        assert len(result.object_list) == 50
+
+    def test_empty_list(self) -> None:
+        result = paginate_list([])
+
+        assert len(result.object_list) == 0
+
+    def test_has_next_page(self) -> None:
+        result = paginate_list(self.object_list, page_number=1)
+
+        assert result.has_next() is True
+
+    def test_has_previous_page(self) -> None:
+        result = paginate_list(self.object_list, page_number=2)
+
+        assert result.has_previous() is True
+
+    def test_last_page_has_no_next(self) -> None:
+        result = paginate_list(self.object_list, page_number=2)
+
+        assert result.has_next() is False
+
+    def test_page_number_exceeds_pages_returns_last_page(self) -> None:
+        result = paginate_list(self.object_list, page_number=999)
+
+        assert result.number == 2
+
+    def test_returns_page_object(self) -> None:
+        result = paginate_list(self.object_list)
+
+        assert isinstance(result, Page)
+
+
+class TestPaginationUrl(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def _create_context(self, request) -> MagicMock:
+        context = MagicMock()
+        context.request = request
+        return context
+
+    def test_custom_page_name(self) -> None:
+        request = self.factory.get('/')
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=2, page_name='p')
+
+        assert 'p=2' in result
+
+    def test_default_page_name(self) -> None:
+        request = self.factory.get('/')
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=1)
+
+        assert 'page=1' in result
+
+    def test_multiple_query_params(self) -> None:
+        request = self.factory.get('/', {'filter': 'active', 'sort': 'name'})
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=3)
+
+        assert 'page=3' in result
+        assert 'filter=active' in result
+        assert 'sort=name' in result
+
+    def test_preserves_existing_query_params(self) -> None:
+        request = self.factory.get('/', {'search': 'test'})
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=2)
+
+        assert 'search=test' in result
+        assert 'page=2' in result
+
+    def test_replaces_space_with_plus(self) -> None:
+        request = self.factory.get('/', {'search': 'hello world'})
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=1)
+
+        assert 'search=hello+world' in result
+
+    def test_returns_query_string(self) -> None:
+        request = self.factory.get('/')
+        context = self._create_context(request)
+
+        result = pagination_url(context, page_number=1)
+
+        assert result.startswith('?')
+
+
+class TestGetElidedPageRange(TestCase):
+    def test_custom_on_each_side(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 5
+        page_obj.paginator.get_elided_page_range.return_value = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+        get_elided_page_range(page_obj, on_each_side=3)
+
+        page_obj.paginator.get_elided_page_range.assert_called_once_with(
+            number=5,
+            on_each_side=3,
+            on_ends=2
+        )
+
+    def test_custom_on_ends(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 5
+        page_obj.paginator.get_elided_page_range.return_value = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+        get_elided_page_range(page_obj, on_ends=3)
+
+        page_obj.paginator.get_elided_page_range.assert_called_once_with(
+            number=5,
+            on_each_side=2,
+            on_ends=3
+        )
+
+    def test_default_parameters(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 1
+        page_obj.paginator.get_elided_page_range.return_value = [1, 2, 3]
+
+        get_elided_page_range(page_obj)
+
+        page_obj.paginator.get_elided_page_range.assert_called_once_with(
+            number=1,
+            on_each_side=2,
+            on_ends=2
+        )
+
+    def test_returns_elided_page_range(self) -> None:
+        page_obj = MagicMock()
+        page_obj.number = 1
+        expected_range = [1, 2, 3, '...', 10]
+        page_obj.paginator.get_elided_page_range.return_value = expected_range
+
+        result = get_elided_page_range(page_obj)
+
+        assert result == expected_range

django_spire/contrib/performance/decorators.py

@@ -1,21 +1,31 @@
+from __future__ import annotations
+
 import logging
 import time
 
+from typing import Callable, ParamSpec, TypeVar
+
 from django.conf import settings
 
 
-def performance_timer(func):
-    def wrapper(*args, **kwargs):
+P = ParamSpec('P')
+R = TypeVar('R')
+
+log = logging.getLogger(__name__)
+
+
+def performance_timer(func: Callable[P, R]) -> Callable[P, R]:
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         if settings.DEBUG:
             start_time = time.perf_counter()
             result = func(*args, **kwargs)
             end_time = time.perf_counter()
 
-            logging.warning(f'{end_time - start_time:.4f} seconds runtime for "{func.__module__}.{func.__qualname__}"')
+            message = f'{end_time - start_time:.4f} seconds runtime for "{func.__module__}.{func.__qualname__}"'
+            log.warning(message)
 
             return result
 
-        else:
-            return func(*args, **kwargs)
+        return func(*args, **kwargs)
 
-    return wrapper
+    return wrapper

django_spire/contrib/performance/tests/test_performance.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from django.test import TestCase, override_settings
+
+from django_spire.contrib.performance.decorators import performance_timer
+
+
+class TestPerformanceTimer(TestCase):
+    @override_settings(DEBUG=True)
+    def test_calls_function_when_debug_true(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        result = sample_func()
+
+        assert result == 'result'
+
+    @override_settings(DEBUG=False)
+    def test_calls_function_when_debug_false(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        result = sample_func()
+
+        assert result == 'result'
+
+    @override_settings(DEBUG=True)
+    def test_logs_warning_when_debug_true(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            mock_warning.assert_called_once()
+
+    @override_settings(DEBUG=False)
+    def test_no_logging_when_debug_false(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            mock_warning.assert_not_called()
+
+    @override_settings(DEBUG=True)
+    def test_log_message_contains_runtime(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            log_message = mock_warning.call_args[0][0]
+
+            assert 'seconds runtime' in log_message
+
+    @override_settings(DEBUG=True)
+    def test_log_message_contains_function_name(self) -> None:
+        @performance_timer
+        def sample_func() -> str:
+            return 'result'
+
+        with patch('django_spire.contrib.performance.decorators.log.warning') as mock_warning:
+            sample_func()
+
+            log_message = mock_warning.call_args[0][0]
+
+            assert 'sample_func' in log_message
+
+    @override_settings(DEBUG=True)
+    def test_passes_args_to_function(self) -> None:
+        @performance_timer
+        def sample_func(a: int, b: int) -> int:
+            return a + b
+
+        result = sample_func(2, 3)
+
+        assert result == 5
+
+    @override_settings(DEBUG=True)
+    def test_passes_kwargs_to_function(self) -> None:
+        @performance_timer
+        def sample_func(a: int, b: int = 10) -> int:
+            return a + b
+
+        result = sample_func(5, b=20)
+
+        assert result == 25
+
+    @override_settings(DEBUG=True)
+    def test_returns_none_when_function_returns_none(self) -> None:
+        @performance_timer
+        def sample_func() -> None:
+            pass
+
+        result = sample_func()
+
+        assert result is None

django_spire/contrib/queryset/enums.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from enum import StrEnum
 
 
 class SessionFilterActionEnum(StrEnum):
     CLEAR = 'Clear'
-    FILTER = 'Filter'
+    FILTER = 'Filter'

django_spire/contrib/queryset/filter_tools.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
-from django.db.models import QuerySet
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
 
 
 def filter_by_lookup_map(
-        queryset: QuerySet,
-        lookup_map: dict,
-        data: dict,
-        extra_filters: dict | None = None
+    queryset: QuerySet,
+    lookup_map: dict,
+    data: dict,
+    extra_filters: dict | None = None
 ):
     """
     Filters a given queryset based on a lookup map and provided data. Additional filters
@@ -23,7 +26,9 @@ def filter_by_lookup_map(
 
     Returns:
         QuerySet: The filtered queryset.
+
     """
+
     if extra_filters is None:
         extra_filters = {}
 

django_spire/contrib/queryset/mixins.py

@@ -1,25 +1,27 @@
 from __future__ import annotations
 
 import json
+
 from abc import abstractmethod
-from typing import Type
+from typing import TYPE_CHECKING
 
-from django.core.handlers.wsgi import WSGIRequest
 from django.db.models import QuerySet
-from django.forms import Form
 from django_spire.contrib.form.utils import show_form_errors
 from django_spire.contrib.queryset.enums import SessionFilterActionEnum
 from django_spire.contrib.session.controller import SessionController
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.forms import Form
 
-class SessionFilterQuerySetMixin(QuerySet):
 
+class SessionFilterQuerySetMixin(QuerySet):
     def process_session_filter(
-            self,
-            request: WSGIRequest,
-            session_key: str,
-            form_class: Type[Form],
-            is_from_body: bool = False,
+        self,
+        request: WSGIRequest,
+        session_key: str,
+        form_class: type[Form],
+        is_from_body: bool = False
     ) -> QuerySet:
         # Session keys must match to process new queryset data
 
@@ -41,10 +43,9 @@ class SessionFilterQuerySetMixin(QuerySet):
 
             # Apply filters when the user submits the filter form
             if (
-                    action == SessionFilterActionEnum.FILTER
-                    and session_key == data.get('session_filter_key')
+                action == SessionFilterActionEnum.FILTER
+                and session_key == data.get('session_filter_key')
             ):
-
                 # Update session data
                 for key, value in form.cleaned_data.items():
                     session.add_data(key, value)
@@ -56,9 +57,9 @@ class SessionFilterQuerySetMixin(QuerySet):
             # When no new filter data is applied and session is NOT yet expired,
             # return the original queryset
             return self.bulk_filter(session.data)
-        else:
-            show_form_errors(request, form)
-            return self
+
+        show_form_errors(request, form)
+        return self
 
     @abstractmethod
     def bulk_filter(self, filter_data: dict) -> QuerySet:
@@ -66,7 +67,6 @@ class SessionFilterQuerySetMixin(QuerySet):
 
 
 class SearchQuerySetMixin(QuerySet):
-
     @abstractmethod
     def search(self, value: str | None) -> QuerySet:
         pass

django_spire/contrib/queryset/tests/test_queryset.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.db.models import QuerySet
+from django.test import RequestFactory, TestCase
+
+from django_spire.contrib.queryset.enums import SessionFilterActionEnum
+from django_spire.contrib.queryset.filter_tools import filter_by_lookup_map
+from django_spire.contrib.queryset.mixins import SearchQuerySetMixin, SessionFilterQuerySetMixin
+
+
+class TestSessionFilterActionEnum(TestCase):
+    def test_clear_value(self) -> None:
+        assert SessionFilterActionEnum.CLEAR == 'Clear'
+
+    def test_filter_value(self) -> None:
+        assert SessionFilterActionEnum.FILTER == 'Filter'
+
+    def test_is_str_enum(self) -> None:
+        assert isinstance(SessionFilterActionEnum.CLEAR, str)
+        assert isinstance(SessionFilterActionEnum.FILTER, str)
+
+
+class TestFilterByLookupMap(TestCase):
+    def setUp(self) -> None:
+        self.queryset = MagicMock(spec=QuerySet)
+        self.queryset.filter.return_value = self.queryset
+
+    def test_applies_filter_from_lookup_map(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test'}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_extra_filters_applied(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test'}
+        extra_filters = {'is_active': True}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data, extra_filters)
+
+        self.queryset.filter.assert_called_once_with(
+            name__icontains='test',
+            is_active=True
+        )
+
+    def test_extra_filters_defaults_to_empty_dict(self) -> None:
+        lookup_map = {}
+        data = {}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with()
+
+    def test_ignores_empty_string_values(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'email': 'email__icontains'}
+        data = {'name': 'test', 'email': ''}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_ignores_keys_not_in_lookup_map(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test', 'other': 'value'}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_ignores_none_values(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'email': 'email__icontains'}
+        data = {'name': 'test', 'email': None}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_ignores_empty_list_values(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'tags': 'tags__in'}
+        data = {'name': 'test', 'tags': []}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(name__icontains='test')
+
+    def test_multiple_filters_applied(self) -> None:
+        lookup_map = {'name': 'name__icontains', 'status': 'status'}
+        data = {'name': 'test', 'status': 'active'}
+
+        filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        self.queryset.filter.assert_called_once_with(
+            name__icontains='test',
+            status='active'
+        )
+
+    def test_returns_filtered_queryset(self) -> None:
+        lookup_map = {'name': 'name__icontains'}
+        data = {'name': 'test'}
+
+        result = filter_by_lookup_map(self.queryset, lookup_map, data)
+
+        assert result == self.queryset
+
+
+class TestSessionFilterQuerySetMixin(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def _create_request_with_session(self, path: str = '/', data: dict | None = None):
+        request = self.factory.get(path, data or {})
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        return request
+
+    def test_has_bulk_filter_abstract_method(self) -> None:
+        assert hasattr(SessionFilterQuerySetMixin, 'bulk_filter')
+
+    def test_has_process_session_filter_method(self) -> None:
+        assert hasattr(SessionFilterQuerySetMixin, 'process_session_filter')
+
+    def test_is_queryset_subclass(self) -> None:
+        assert issubclass(SessionFilterQuerySetMixin, QuerySet)
+
+
+class TestSearchQuerySetMixin(TestCase):
+    def test_has_search_abstract_method(self) -> None:
+        assert hasattr(SearchQuerySetMixin, 'search')
+
+    def test_is_queryset_subclass(self) -> None:
+        assert issubclass(SearchQuerySetMixin, QuerySet)

django_spire/contrib/seeding/field/base.py

@@ -1,24 +1,30 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
 from django_spire.contrib.seeding.field.cleaners import normalize_seeder_fields
 from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class BaseFieldSeeder(ABC):
     keyword: str = None
     seed_keywords = FieldSeederTypesEnum._value2member_map_.keys()
 
     def __init__(
-            self,
-            fields: dict = None,
-            default_to: str = "llm"
-    ):
+        self,
+        fields: dict | None = None,
+        default_to: str = 'llm'
+    ) -> None:
 
         self.fields = self._normalize_fields(fields or {})
         self.default_to = default_to
 
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
         if cls.keyword is None:
@@ -35,9 +41,9 @@ class BaseFieldSeeder(ABC):
         }
 
     @property
-    def seeder_fields(self):
+    def seeder_fields(self) -> dict:
         return self.filter_fields(self.keyword)
 
     @abstractmethod
-    def seed(self, model_seeder_cls, count: int):
+    def seed(self, model_seeder_cls: Any, count: int) -> list[dict]:
         pass

django_spire/contrib/seeding/field/callable.py

@@ -1,11 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django_spire.contrib.seeding.field.base import BaseFieldSeeder
 from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class CallableFieldSeeder(BaseFieldSeeder):
     keyword = FieldSeederTypesEnum.CALLABLE
 
-    def seed(self, manager = None, count = 1) -> list[dict]:
+    def seed(self, manager: Any = None, count: int = 1) -> list[dict]:
         return [
             {field_name: func[1]() for field_name, func in self.seeder_fields.items()}
             for _ in range(count)

django_spire/contrib/seeding/field/cleaners.py

@@ -1,7 +1,10 @@
-from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
+from __future__ import annotations
 
 import copy
 
+from django_spire.contrib.seeding.field.enums import FieldSeederTypesEnum
+
+
 def normalize_seeder_fields(fields: dict) -> dict:
     normalized = {}
 
@@ -21,14 +24,11 @@ def normalize_seeder_fields(fields: dict) -> dict:
                 else:
                     extra = (extra_value,)
 
-            normalized[k] = (v[0],) + v[1:2] + extra
-
+            normalized[k] = (v[0], *v[1:2], *extra)
         elif callable(v):
             normalized[k] = ("callable", v)
-
         elif isinstance(v, str) and v.lower() in FieldSeederTypesEnum._value2member_map_:
             normalized[k] = (v.lower(),)
-
         else:
             normalized[k] = ("static", v)