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

django_spire/contrib/options/tests/test_options.py

@@ -0,0 +1,234 @@
+import pytest
+
+from django.test import RequestFactory, TestCase
+from unittest.mock import MagicMock
+
+from django_spire.contrib.options.mixins import OptionsModelMixin
+from django_spire.contrib.options.options import Option, Options, OptionSection
+from django_spire.contrib.options.tests import factories
+
+
+class TestOption(TestCase):
+    def test_init(self) -> None:
+        option = Option('email', True)
+
+        assert option.key == 'email'
+        assert option.value is True
+
+    def test_value_can_be_string(self) -> None:
+        option = Option('timezone', 'America/Edmonton')
+
+        assert option.value == 'America/Edmonton'
+
+    def test_value_can_be_int(self) -> None:
+        option = Option('volume', 50)
+
+        assert option.value == 50
+
+    def test_value_can_be_bool(self) -> None:
+        option = Option('enabled', False)
+
+        assert option.value is False
+
+
+class TestOptionSection(TestCase):
+    def test_contains_existing_option(self) -> None:
+        section = factories.create_test_option_section()
+
+        assert 'email' in section
+
+    def test_contains_missing_option(self) -> None:
+        section = factories.create_test_option_section()
+
+        assert 'invalid' not in section
+
+    def test_equal(self) -> None:
+        section1 = factories.create_test_option_section()
+        section2 = factories.create_test_option_section()
+
+        assert section1 == section2
+
+    def test_getitem(self) -> None:
+        section = factories.create_test_option_section()
+
+        assert isinstance(section['email'], Option)
+        assert section['email'].value is True
+
+    def test_getitem_case_insensitive(self) -> None:
+        section = factories.create_test_option_section()
+
+        assert section['EMAIL'].value is True
+
+    def test_getitem_key_error(self) -> None:
+        section = factories.create_test_option_section()
+
+        with pytest.raises(KeyError):
+            section['invalid']
+
+    def test_not_equal(self) -> None:
+        section1 = factories.create_test_option_section()
+        section2 = OptionSection(
+            name='other',
+            options=[Option('different', 'value')]
+        )
+
+        assert section1 != section2
+
+    def test_to_dict(self) -> None:
+        section = factories.create_test_option_section()
+        expected = {'email': True, 'push': False}
+
+        assert section.to_dict() == expected
+
+
+class TestOptions(TestCase):
+    def test_contains_existing_section(self) -> None:
+        options = factories.create_test_options()
+
+        assert 'notification' in options
+
+    def test_contains_missing_section(self) -> None:
+        options = factories.create_test_options()
+
+        assert 'invalid' not in options
+
+    def test_equal_same_structure(self) -> None:
+        options1 = factories.create_test_options()
+        options2 = factories.create_test_options()
+
+        assert options1 == options2
+
+    def test_equal_different_sections(self) -> None:
+        options1 = factories.create_test_options()
+        options2 = Options.load_dict({
+            'General': {'volume': 10},
+            'Notifications': {'email': True}
+        })
+
+        assert options1 != options2
+
+    def test_equal_different_values_same_keys(self) -> None:
+        options1 = Options.load_dict({
+            'General': {'volume': 10, 'language': 'en'},
+            'Notifications': {'email': True}
+        })
+        options2 = Options.load_dict({
+            'General': {'volume': 10},
+            'Notifications': {'email': True}
+        })
+
+        assert options1 != options2
+
+    def test_get_setting(self) -> None:
+        options = factories.create_test_options()
+
+        assert options.get_setting('notification', 'push') is False
+
+    def test_getitem(self) -> None:
+        options = factories.create_test_options()
+
+        assert isinstance(options['notification'], OptionSection)
+        assert isinstance(options['notification']['push'], Option)
+        assert options['notification']['push'].value is False
+
+    def test_getitem_case_insensitive(self) -> None:
+        options = factories.create_test_options()
+
+        assert options['NOTIFICATION']['PUSH'].value is False
+
+    def test_getitem_key_error(self) -> None:
+        options = factories.create_test_options()
+
+        with pytest.raises(KeyError):
+            options['invalid']
+
+    def test_load_dict(self) -> None:
+        options_dict = factories.create_test_options_dict()
+        options = Options.load_dict(options_dict)
+
+        assert options.get_setting('notification', 'push') is False
+        assert 'notification' in options
+
+    def test_sync_options_adds_new_sections(self) -> None:
+        original = Options.load_dict({
+            'General': {'volume': 10},
+        })
+        new_structure = Options.load_dict({
+            'General': {'volume': 5},
+            'Privacy': {'location': False}
+        })
+
+        original.sync_options(new_structure)
+
+        assert 'Privacy' in original
+
+    def test_sync_options_adds_new_settings(self) -> None:
+        original = Options.load_dict({
+            'General': {'volume': 10},
+        })
+        new_structure = Options.load_dict({
+            'General': {'volume': 5, 'brightness': 70},
+        })
+
+        original.sync_options(new_structure)
+
+        assert 'brightness' in original['General']
+
+    def test_sync_options_preserves_existing_values(self) -> None:
+        original = Options.load_dict({
+            'General': {'volume': 10},
+        })
+        new_structure = Options.load_dict({
+            'General': {'volume': 5, 'brightness': 70},
+        })
+
+        original.sync_options(new_structure)
+
+        assert original.get_setting('General', 'volume') == 10
+
+    def test_to_dict(self) -> None:
+        options = factories.create_test_options()
+        expected = factories.create_test_options_dict()
+
+        assert options.to_dict() == expected
+
+    def test_update_setting(self) -> None:
+        options = factories.create_test_options()
+
+        options.update_setting('notification', 'push', True)
+
+        assert options.get_setting('notification', 'push') is True
+
+
+class TestOptionsModelMixin(TestCase):
+    def test_get_option(self) -> None:
+        mixin = MagicMock(spec=OptionsModelMixin)
+        mixin._default_options = factories.create_test_options()
+        mixin.options = factories.create_test_options()
+        mixin._options = mixin.options.to_dict()
+
+        result = OptionsModelMixin.get_option(mixin, 'notification', 'email')
+
+        assert result is True
+
+    def test_update_option(self) -> None:
+        mixin = MagicMock(spec=OptionsModelMixin)
+        mixin._default_options = factories.create_test_options()
+        mixin.options = factories.create_test_options()
+        mixin._options = mixin.options.to_dict()
+
+        OptionsModelMixin.update_option(mixin, 'notification', 'email', False, commit=False)
+
+        assert mixin.options.get_setting('notification', 'email') is False
+        assert mixin._options == mixin.options.to_dict()
+
+    def test_update_session(self) -> None:
+        mixin = MagicMock(spec=OptionsModelMixin)
+        mixin.options = factories.create_test_options()
+
+        request = RequestFactory().get('/')
+        request.session = {}
+
+        OptionsModelMixin.update_session(mixin, request)
+
+        assert request.session['user_options'] == mixin.options.to_dict()

django_spire/contrib/ordering/exceptions.py

@@ -1,5 +1,9 @@
-class OrderingMixinExceptionGroup(Exception):
+from __future__ import annotations
+
+
+class OrderingMixinGroupError(Exception):
     pass
 
-class OrderingMixinException(Exception):
-    pass
+
+class OrderingMixinError(Exception):
+    pass

django_spire/contrib/ordering/mixins.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.db import models
 
 from django_spire.contrib.ordering.services.service import OrderingService

django_spire/contrib/ordering/querysets.py

@@ -1,4 +1,6 @@
-from django.db.models import QuerySet, F
+from __future__ import annotations
+
+from django.db.models import QuerySet
 
 
 class OrderingQuerySetMixin(QuerySet):

django_spire/contrib/ordering/services/processor_service.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from django_spire.contrib.ordering.exceptions import OrderingMixinExceptionGroup
+from django_spire.contrib.ordering.exceptions import OrderingMixinGroupError
 from django_spire.contrib.ordering.validators import OrderingMixinValidator
 from django_spire.contrib.service import BaseDjangoModelService
 
@@ -55,8 +55,10 @@ class OrderingProcessorService(BaseDjangoModelService['OrderingModelMixin']):
         )
 
         if not ordering_mixin_validator.validate():
-            raise OrderingMixinExceptionGroup(
-                'Ordering validation failed.',
+            message = 'Ordering validation failed.'
+
+            raise OrderingMixinGroupError(
+                message,
                 ordering_mixin_validator.errors
             )
 
@@ -84,8 +86,10 @@ class OrderingProcessorService(BaseDjangoModelService['OrderingModelMixin']):
         )
 
         if not ordering_mixin_validator.validate():
+            message = 'Ordering validation failed.'
+
             raise ExceptionGroup(
-                'Ordering validation failed.',
+                message,
                 ordering_mixin_validator.errors
             )
 

django_spire/contrib/ordering/services/service.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from django_spire.contrib.ordering.services.processor_service import \
-    OrderingProcessorService
+from django_spire.contrib.ordering.services.processor_service import OrderingProcessorService
 from django_spire.contrib.service import BaseDjangoModelService
 
 if TYPE_CHECKING:

django_spire/contrib/ordering/tests/test_ordering.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import pytest
+
+from unittest.mock import MagicMock
+
+from django.test import TestCase
+
+from django_spire.contrib.ordering.exceptions import OrderingMixinError, OrderingMixinGroupError
+from django_spire.contrib.ordering.mixins import OrderingModelMixin
+from django_spire.contrib.ordering.services.processor_service import OrderingProcessorService
+from django_spire.contrib.ordering.services.service import OrderingService
+from django_spire.contrib.ordering.validators import OrderingMixinValidator
+
+
+class TestOrderingMixinError(TestCase):
+    def test_can_be_raised(self) -> None:
+        with pytest.raises(OrderingMixinError):
+            message = 'Test'
+            raise OrderingMixinError(message)
+
+    def test_is_exception(self) -> None:
+        assert issubclass(OrderingMixinError, Exception)
+
+    def test_message(self) -> None:
+        error = OrderingMixinError('Test error message')
+
+        assert str(error) == 'Test error message'
+
+
+class TestOrderingMixinGroupError(TestCase):
+    def test_can_be_raised(self) -> None:
+        with pytest.raises(OrderingMixinGroupError):
+            message = 'Test'
+            raise OrderingMixinGroupError(message)
+
+    def test_is_exception(self) -> None:
+        assert issubclass(OrderingMixinGroupError, Exception)
+
+    def test_message(self) -> None:
+        error = OrderingMixinGroupError('Test group error message')
+
+        assert str(error) == 'Test group error message'
+
+
+class TestOrderingMixinValidator(TestCase):
+    def setUp(self) -> None:
+        self.obj = MagicMock()
+        self.obj.pk = 1
+
+        self.destination_objects = MagicMock()
+        self.destination_objects.__len__ = MagicMock(return_value=5)
+
+        self.origin_objects = MagicMock()
+        self.origin_objects.__len__ = MagicMock(return_value=5)
+
+    def test_errors_contain_ordering_mixin_error(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=-1,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        validator.validate()
+
+        assert all(isinstance(error, OrderingMixinError) for error in validator.errors)
+
+    def test_errors_property_returns_list(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=0,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        assert isinstance(validator.errors, list)
+
+    def test_validate_position_at_boundary(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=5,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        assert validator.validate() is True
+
+    def test_validate_position_zero(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=0,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        assert validator.validate() is True
+
+    def test_validate_returns_false_for_negative_position(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=-1,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        assert validator.validate() is False
+        assert len(validator.errors) == 1
+
+    def test_validate_returns_false_for_position_greater_than_objects(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=10,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        assert validator.validate() is False
+        assert len(validator.errors) == 1
+
+    def test_validate_returns_true_for_valid_position(self) -> None:
+        validator = OrderingMixinValidator(
+            destination_objects=self.destination_objects,
+            position=2,
+            obj=self.obj,
+            origin_objects=self.origin_objects
+        )
+
+        assert validator.validate() is True
+
+
+class TestOrderingModelMixin(TestCase):
+    def test_has_order_field(self) -> None:
+        assert hasattr(OrderingModelMixin, 'order')
+
+    def test_has_ordering_services_in_dict(self) -> None:
+        assert 'ordering_services' in OrderingModelMixin.__dict__
+
+    def test_is_abstract(self) -> None:
+        assert OrderingModelMixin._meta.abstract is True
+
+    def test_order_default_value(self) -> None:
+        assert OrderingModelMixin._meta.get_field('order').default == 0
+
+
+class TestOrderingProcessorService(TestCase):
+    def test_has_move_to_position_method(self) -> None:
+        assert hasattr(OrderingProcessorService, 'move_to_position')
+
+    def test_has_remove_from_objects_method(self) -> None:
+        assert hasattr(OrderingProcessorService, 'remove_from_objects')
+
+    def test_has_reorder_destination_and_origin_objects_method(self) -> None:
+        assert hasattr(OrderingProcessorService, '_reorder_destination_and_origin_objects')
+
+    def test_has_reorder_objects_method(self) -> None:
+        assert hasattr(OrderingProcessorService, '_reorder_objects')
+
+
+class TestOrderingService(TestCase):
+    def test_has_processor_in_dict(self) -> None:
+        assert 'processor' in OrderingService.__dict__
+
+    def test_processor_in_dict_is_ordering_processor_service(self) -> None:
+        assert isinstance(OrderingService.__dict__['processor'], OrderingProcessorService)

django_spire/contrib/ordering/validators.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from django_spire.contrib.ordering.exceptions import OrderingMixinException
+from django_spire.contrib.ordering.exceptions import OrderingMixinError
 
 if TYPE_CHECKING:
     from django.db.models import Model, QuerySet
@@ -21,11 +21,11 @@ class OrderingMixinValidator:
         self._origin_objects = origin_objects
         self._obj = obj
 
-        self._errors: list[OrderingMixinException] = []
+        self._errors: list[OrderingMixinError] = []
 
     @property
-    def errors(self) -> list[OrderingMixinException]:
-        """Returns list of OrderingMixinException errors."""
+    def errors(self) -> list[OrderingMixinError]:
+        """Returns list of OrderingMixinError errors."""
         return self._errors
 
     def validate(self) -> bool:
@@ -40,7 +40,7 @@ class OrderingMixinValidator:
     def _validate_position(self):
         """Ensure position is valid."""
         if self._position < 0 or not isinstance(self._position, int):
-            self._errors.append(OrderingMixinException('Position must be a positive number.'))
+            self._errors.append(OrderingMixinError('Position must be a positive number.'))
 
         if self._position > len(self._destination_objects):
-            self._errors.append(OrderingMixinException('Position must be less than the number of destination objects.'))
+            self._errors.append(OrderingMixinError('Position must be less than the number of destination objects.'))

django_spire/contrib/pagination/templatetags/pagination_tags.py

@@ -1,18 +1,25 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from django import template
 
+if TYPE_CHECKING:
+    from typing import Any, Iterator
+
+    from django.core.paginator import Page
+
 
 register = template.Library()
 
 
 @register.simple_tag(takes_context=True)
 def pagination_url(
-    context,
+    context: template.Context,
     page_number: int,
     page_name: str = 'page',
-    **kwargs
-):
+    **kwargs: Any
+) -> str:
     updated_context = context.request.GET.copy()
     updated_context[page_name] = page_number
     query_string = '?'
@@ -33,10 +40,10 @@ def pagination_url(
 
 @register.simple_tag
 def get_elided_page_range(
-    page_obj,
+    page_obj: Page[Any],
     on_each_side: int = 2,
     on_ends: int = 2
-):
+) -> Iterator[int | str]:
     return page_obj.paginator.get_elided_page_range(
         number=page_obj.number,
         on_each_side=on_each_side,