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

django_spire/contrib/service/tests/test_service.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import pytest
+
+from unittest.mock import patch
+
+from django.contrib.auth.models import User
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+
+from django_spire.contrib.service import BaseDjangoModelService, ServiceError
+
+
+class UserService(BaseDjangoModelService[User]):
+    obj: User
+
+
+class TestServiceError(TestCase):
+    def test_can_be_raised(self) -> None:
+        with pytest.raises(ServiceError):
+            message = 'Test'
+            raise ServiceError(message)
+
+    def test_is_exception(self) -> None:
+        assert issubclass(ServiceError, Exception)
+
+    def test_message(self) -> None:
+        error = ServiceError('Test error message')
+
+        assert str(error) == 'Test error message'
+
+
+class TestBaseDjangoModelService(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+
+    def test_get_concrete_fields_returns_dict(self) -> None:
+        service = UserService(self.user)
+
+        result = service._get_concrete_fields()
+
+        assert isinstance(result, dict)
+        assert 'username' in result
+        assert 'email' in result
+
+    def test_get_touched_fields_returns_list(self) -> None:
+        service = UserService(self.user)
+        concrete_fields = service._get_concrete_fields()
+
+        result = service._get_touched_fields(concrete_fields, username='newuser')
+
+        assert isinstance(result, list)
+
+    def test_get_touched_fields_sets_attribute(self) -> None:
+        service = UserService(self.user)
+        concrete_fields = service._get_concrete_fields()
+
+        service._get_touched_fields(concrete_fields, first_name='NewName')
+
+        assert service.obj.first_name == 'NewName'
+
+    def test_get_touched_fields_logs_warning_for_invalid_field(self) -> None:
+        service = UserService(self.user)
+        concrete_fields = service._get_concrete_fields()
+
+        with patch('django_spire.contrib.service.django_model_service.log') as mock_log:
+            service._get_touched_fields(concrete_fields, invalid_field='value')
+
+            mock_log.warning.assert_called_once()
+
+    def test_get_touched_fields_skips_auto_created_fields(self) -> None:
+        service = UserService(self.user)
+        concrete_fields = service._get_concrete_fields()
+
+        result = service._get_touched_fields(concrete_fields, id=999)
+
+        assert 'id' not in result
+
+    def test_has_get_concrete_fields_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, '_get_concrete_fields')
+
+    def test_has_get_touched_fields_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, '_get_touched_fields')
+
+    def test_has_save_model_obj_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, 'save_model_obj')
+
+    def test_has_validate_model_obj_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, 'validate_model_obj')
+
+    def test_save_model_obj_raises_error_without_field_data(self) -> None:
+        service = UserService(self.user)
+
+        with pytest.raises(ServiceError, match='Field data is required'):
+            service.save_model_obj()
+
+    def test_save_model_obj_returns_tuple(self) -> None:
+        service = UserService(self.user)
+
+        result = service.save_model_obj(first_name='Updated')
+
+        assert isinstance(result, tuple)
+        assert len(result) == 2
+
+    def test_save_model_obj_returns_model_and_bool(self) -> None:
+        service = UserService(self.user)
+
+        obj, created = service.save_model_obj(first_name='Updated')
+
+        assert isinstance(obj, User)
+        assert isinstance(created, bool)
+
+    def test_save_model_obj_updates_existing_model(self) -> None:
+        service = UserService(self.user)
+
+        obj, created = service.save_model_obj(first_name='UpdatedName')
+
+        assert created is False
+        assert obj.first_name == 'UpdatedName'
+
+    def test_save_model_obj_creates_new_model(self) -> None:
+        new_user = User(username='newuser', email='new@test.com')
+        service = UserService(new_user)
+
+        obj, created = service.save_model_obj(username='newuser', email='new@test.com')
+
+        assert created is True
+        assert obj.pk is not None
+
+    def test_save_model_obj_logs_warning_when_no_changes(self) -> None:
+        service = UserService(self.user)
+
+        with patch('django_spire.contrib.service.django_model_service.log') as mock_log:
+            service.save_model_obj(id=self.user.id)
+
+            mock_log.warning.assert_called_once()
+
+    def test_validate_model_obj_returns_touched_fields(self) -> None:
+        service = UserService(self.user)
+
+        result = service.validate_model_obj(first_name='Valid')
+
+        assert isinstance(result, list)
+        assert 'first_name' in result
+
+    def test_validate_model_obj_raises_validation_error(self) -> None:
+        service = UserService(self.user)
+
+        with pytest.raises(ValidationError):
+            service.validate_model_obj(email='invalid-email')

django_spire/contrib/session/apps.py

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

django_spire/contrib/session/controller.py

@@ -1,34 +1,40 @@
 from __future__ import annotations
 
 import json
+
 from datetime import datetime, timedelta
-from typing import Any
+from typing import TYPE_CHECKING
 
 from django.core.serializers.json import DjangoJSONEncoder
-from django.http import HttpRequest
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from django.http import HttpRequest
 
 
 class SessionController:
     """
-        This class provides an interface for storing, retrieving, and managing session data
-        with automatic expiration. It handles session data under a specific key and supports
-        timeout-based cleanup of expired sessions.
-
-        Args:
-            request (HttpRequest): The Django request object containing the session.
-            session_key (str): Unique key under which the session data will be stored.
-            seconds_till_expiry (int, optional): Number of seconds until session expiry.
-                Defaults to 300 seconds (5 minutes).
+    This class provides an interface for storing, retrieving, and managing session data
+    with automatic expiration. It handles session data under a specific key and supports
+    timeout-based cleanup of expired sessions.
+
+    Args:
+        request (HttpRequest): The Django request object containing the session.
+        session_key (str): Unique key under which the session data will be stored.
+        seconds_till_expiry (int, optional): Number of seconds until session expiry.
+            Defaults to 300 seconds (5 minutes).
+
     """
 
     _TIMEOUT_KEY = '_timeout_datestamp'
 
     def __init__(
-            self,
-            request: HttpRequest,
-            session_key: str,
-            seconds_till_expiry: int = 60 * 5
-    ):
+        self,
+        request: HttpRequest,
+        session_key: str,
+        seconds_till_expiry: int = 60 * 5
+    ) -> None:
         self.request = request
         self.session_key = session_key
         self.seconds_till_expiry = seconds_till_expiry
@@ -41,28 +47,44 @@ class SessionController:
     def __getitem__(self, key: str) -> Any:
         return self.data[key]
 
-    def __setitem__(self, key: str, value: Any):
+    def __setitem__(self, key: str, value: Any) -> None:
         self.add_data(key, value)
 
-    def add_data(self, key: str, data: Any):
+    def _clean(self) -> None:
+        if self._TIMEOUT_KEY in self.data and self.is_expired:
+            self.request.session.pop(self.session_key)
+            self._set_modified()
+
+    def _set_modified(self) -> None:
+        self.request.session.modified = True
+
+    def _set_timeout_datestamp(self) -> None:
+        timeout_datetime = datetime.now() + timedelta(seconds=self.seconds_till_expiry)
+        self.data[self._TIMEOUT_KEY] = timeout_datetime.timestamp()
+
+    def add_data(self, key: str, data: Any) -> None:
         self._session[key] = data
         self._set_timeout_datestamp()
         self._set_modified()
 
     @property
-    def data(self):
+    def data(self) -> dict[str, Any]:
         return self._session
 
+    @property
+    def has_data(self) -> bool:
+        return bool(self.data)
+
     @property
     def is_expired(self) -> bool:
         current_timestamp = datetime.now().timestamp()
         return self.timeout_datestamp < current_timestamp
 
-    @property
-    def timeout_datestamp(self) -> float:
-        return self.data.get(self._TIMEOUT_KEY, 0)
+    def purge(self) -> None:
+        self.request.session.pop(self.session_key)
+        self._set_modified()
 
-    def remove_data(self, key: str):
+    def remove_data(self, key: str) -> None:
         self.data.pop(key)
         self._set_modified()
 
@@ -70,25 +92,9 @@ class SessionController:
         if self._TIMEOUT_KEY in self.data and len(self.data.keys()) == 1:
             self.data.pop(self._TIMEOUT_KEY)
 
-    def purge(self):
-        self.request.session.pop(self.session_key)
-        self._set_modified()
-
-    def _clean(self) -> None:
-        if self._TIMEOUT_KEY in self.data and self.is_expired:
-            self.request.session.pop(self.session_key)
-            self._set_modified()
-
-    def _set_modified(self):
-        self.request.session.modified = True
-
     @property
-    def has_data(self) -> bool:
-        return bool(self.data)
-
-    def _set_timeout_datestamp(self):
-        timeout_datetime = datetime.now() + timedelta(seconds=self.seconds_till_expiry)
-        self.data[self._TIMEOUT_KEY] = timeout_datetime.timestamp()
+    def timeout_datestamp(self) -> float:
+        return self.data.get(self._TIMEOUT_KEY, 0)
 
-    def to_json(self):
+    def to_json(self) -> str:
         return json.dumps(self.data, cls=DjangoJSONEncoder)

django_spire/contrib/session/templatetags/session_tags.py

@@ -1,15 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django import template
 from django.utils.html import escapejs
 from django.utils.safestring import mark_safe
 
 from django_spire.contrib.session.controller import SessionController
 
+if TYPE_CHECKING:
+    from django.template import Context
+    from django.utils.safestring import SafeString
+
+
 register = template.Library()
 
 
 @register.simple_tag(takes_context=True)
-def session_controller_to_json(context, key):
-    request = context.get("request")
+def session_controller_to_json(context: Context, key: str) -> SafeString:
+    request = context.get('request')
     controller = SessionController(request, key)
     data = controller.to_json()
     return mark_safe(escapejs(data))

django_spire/contrib/session/tests/test_session_controller.py

@@ -1,18 +1,21 @@
+from __future__ import annotations
+
 from datetime import datetime
+from unittest.mock import MagicMock
 
-from django.test import TestCase, RequestFactory
 from django.contrib.sessions.middleware import SessionMiddleware
 from django.contrib.sessions.models import Session
+from django.test import RequestFactory, TestCase
 
 from django_spire.contrib.session.controller import SessionController
+from django_spire.contrib.session.templatetags.session_tags import session_controller_to_json
 
 
-class BaseSessionTestCase(TestCase):
-    def setUp(self):
+class TestSessionController(TestCase):
+    def setUp(self) -> None:
         self.factory = RequestFactory()
         self.request = self.factory.get('/')
 
-        # Attach real session
         middleware = SessionMiddleware(lambda req: None)
         middleware.process_request(self.request)
 
@@ -21,85 +24,146 @@ class BaseSessionTestCase(TestCase):
             session_key='shopping_cart'
         )
 
-    def test_base_session_add_data(self):
+    def test_add_data(self) -> None:
         key = 'currency'
         value = 'CAD'
 
         self.shopping_cart_session.add_data(key, value)
-        self.assertIn(key, self.shopping_cart_session.data)
-        self.assertEqual(self.shopping_cart_session.data[key], value)
 
-    def test_base_session_set_item(self):
-        key = 'currency'
-        value = 'CAD'
+        assert key in self.shopping_cart_session.data
+        assert self.shopping_cart_session.data[key] == value
 
-        self.shopping_cart_session[key] = value
-        self.assertIn(key, self.shopping_cart_session.data)
-        self.assertEqual(self.shopping_cart_session.data[key], value)
+    def test_data_property_returns_dict(self) -> None:
+        assert isinstance(self.shopping_cart_session.data, dict)
 
-    def test_base_session_remove_data(self):
+    def test_getitem(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.shopping_cart_session.add_data('discount', None)
-        self.shopping_cart_session.remove_data('currency')
 
-        self.assertNotIn('currency', self.shopping_cart_session.data)
-        self.assertIn('discount', self.shopping_cart_session.data)
+        assert self.shopping_cart_session['currency'] == 'CAD'
 
-    def test_set_session_modified(self):
+    def test_has_data_false_when_empty(self) -> None:
+        assert self.shopping_cart_session.has_data is False
+
+    def test_has_data_true_when_data_exists(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.assertTrue(self.request.session.modified)
 
-    def test_session_has_data(self):
-        self.assertFalse(self.shopping_cart_session.has_data)
+        assert self.shopping_cart_session.has_data is True
 
+    def test_has_data_false_after_remove(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.assertTrue(self.shopping_cart_session.has_data)
+        self.shopping_cart_session.remove_data('currency')
 
+        assert self.shopping_cart_session.has_data is False
 
-        self.shopping_cart_session.remove_data('currency')
-        self.assertFalse(self.shopping_cart_session.has_data)
+    def test_is_expired_false_when_not_expired(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
 
-    def test_session_data_to_json(self):
+        assert self.shopping_cart_session.is_expired is False
+
+    def test_is_expired_true_when_expired(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.shopping_cart_session.add_data('discount', None)
+        self.shopping_cart_session.seconds_till_expiry = -5
+        self.shopping_cart_session._set_timeout_datestamp()
 
-        self.assertTrue(isinstance(self.shopping_cart_session.to_json(), str))
+        assert self.shopping_cart_session.is_expired is True
 
-    # def test_to_json_errors_when_not_json_serializable(self):
-    #     self.shopping_cart_session.json_serializable = False
-    #
-    #     with self.assertRaises(ValueError):
-    #         self.shopping_cart_session.to_json()
+    def test_purge_removes_session_data(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.shopping_cart_session.purge()
 
-    def test_set_timeout_datestamp(self):
-        self.shopping_cart_session._set_timeout_datestamp()
-        self.assertIn('_timeout_datestamp', self.shopping_cart_session.data)
-        self.assertTrue(datetime.now().timestamp() < self.shopping_cart_session['_timeout_datestamp'])
+        assert 'shopping_cart' not in self.request.session
 
-    def test_session_data_expiry(self):
+    def test_remove_data(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.assertFalse(self.shopping_cart_session.is_expired)
+        self.shopping_cart_session.add_data('discount', None)
+        self.shopping_cart_session.remove_data('currency')
 
-        self.shopping_cart_session.seconds_till_expiry = -5
-        self.shopping_cart_session._set_timeout_datestamp()
-        self.assertTrue(self.shopping_cart_session.is_expired)
+        assert 'currency' not in self.shopping_cart_session.data
+        assert 'discount' in self.shopping_cart_session.data
 
-    def test_session_data_added_to_database(self):
-        # Add something to the session
-        self.shopping_cart_session.add_data('favorites', ['cool_shirt', 'fun_hat'] )
+    def test_session_data_added_to_database(self) -> None:
+        self.shopping_cart_session.add_data('favorites', ['cool_shirt', 'fun_hat'])
         self.request.session.save()
 
-        # Get session from DB using session_key
         session_key = self.request.session.session_key
         session_in_db = Session.objects.get(session_key=session_key)
-
-        # Decode the session data
         session_data = session_in_db.get_decoded()
 
-        self.assertIn(self.shopping_cart_session.session_key, session_data)
-        self.assertIn('favorites', session_data[self.shopping_cart_session.session_key])
-        self.assertEqual(
-            session_data[self.shopping_cart_session.session_key]['favorites'],
-            ['cool_shirt', 'fun_hat']
+        assert self.shopping_cart_session.session_key in session_data
+        assert 'favorites' in session_data[self.shopping_cart_session.session_key]
+        assert session_data[self.shopping_cart_session.session_key]['favorites'] == ['cool_shirt', 'fun_hat']
+
+    def test_set_modified(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
+
+        assert self.request.session.modified is True
+
+    def test_set_timeout_datestamp(self) -> None:
+        self.shopping_cart_session._set_timeout_datestamp()
+
+        assert '_timeout_datestamp' in self.shopping_cart_session.data
+        assert datetime.now().timestamp() < self.shopping_cart_session['_timeout_datestamp']
+
+    def test_setitem(self) -> None:
+        key = 'currency'
+        value = 'CAD'
+
+        self.shopping_cart_session[key] = value
+
+        assert key in self.shopping_cart_session.data
+        assert self.shopping_cart_session.data[key] == value
+
+    def test_timeout_datestamp_returns_float(self) -> None:
+        self.shopping_cart_session._set_timeout_datestamp()
+
+        assert isinstance(self.shopping_cart_session.timeout_datestamp, float)
+
+    def test_timeout_datestamp_returns_zero_when_not_set(self) -> None:
+        controller = SessionController(
+            request=self.request,
+            session_key='new_session'
         )
 
+        assert controller.timeout_datestamp == 0
+
+    def test_to_json_returns_string(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.shopping_cart_session.add_data('discount', None)
+
+        assert isinstance(self.shopping_cart_session.to_json(), str)
+
+
+class TestSessionControllerToJson(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def _create_context_with_session(self) -> MagicMock:
+        request = self.factory.get('/')
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+
+        context = MagicMock()
+        context.get.return_value = request
+
+        return context
+
+    def test_returns_escaped_json(self) -> None:
+        context = self._create_context_with_session()
+
+        result = session_controller_to_json(context, 'test_key')
+
+        assert isinstance(result, str)
+
+    def test_calls_context_get_with_request(self) -> None:
+        context = self._create_context_with_session()
+
+        session_controller_to_json(context, 'test_key')
+
+        context.get.assert_called_once_with('request')
+
+    def test_returns_safe_string(self) -> None:
+        context = self._create_context_with_session()
+
+        result = session_controller_to_json(context, 'test_key')
+
+        assert hasattr(result, '__html__')

django_spire/contrib/tests/test_utils.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire.contrib.utils import truncate_string
+
+
+class TestTruncateString(TestCase):
+    def test_returns_original_when_equal_to_length(self) -> None:
+        result = truncate_string('hello', 5)
+
+        assert result == 'hello'
+
+    def test_returns_original_when_shorter_than_length(self) -> None:
+        result = truncate_string('hi', 10)
+
+        assert result == 'hi'
+
+    def test_truncates_when_longer_than_length(self) -> None:
+        result = truncate_string('hello world', 8)
+
+        assert result == 'hello...'
+
+    def test_truncates_with_ellipsis(self) -> None:
+        result = truncate_string('this is a long string', 10)
+
+        assert result.endswith('...')
+
+    def test_truncated_length_equals_specified_length(self) -> None:
+        result = truncate_string('this is a long string', 10)
+
+        assert len(result) == 10
+
+    def test_empty_string(self) -> None:
+        result = truncate_string('', 5)
+
+        assert result == ''

django_spire/contrib/utils.py

@@ -1,2 +1,5 @@
+from __future__ import annotations
+
+
 def truncate_string(string: str, length: int) -> str:
-    return string[:(length - 3)] + '...' if len(string) > length else string
+    return string[:(length - 3)] + '...' if len(string) > length else string

django_spire/core/apps.py

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