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

django_spire/contrib/seeding/tests/test_intel.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire.contrib.seeding.intelligence.intel import SeedingIntel, SourceIntel
+
+
+class TestSeedingIntel(TestCase):
+    def test_is_iterable(self) -> None:
+        intel = SeedingIntel(items=[{'name': 'test1'}, {'name': 'test2'}])
+
+        result = list(intel)
+
+        assert result == [{'name': 'test1'}, {'name': 'test2'}]
+
+    def test_items_attribute(self) -> None:
+        items = [{'name': 'test'}]
+        intel = SeedingIntel(items=items)
+
+        assert intel.items == items
+
+
+class TestSourceIntel(TestCase):
+    def test_file_name_attribute(self) -> None:
+        intel = SourceIntel(file_name='test.py', python_source_code='print("hello")')
+
+        assert intel.file_name == 'test.py'
+
+    def test_python_source_code_attribute(self) -> None:
+        intel = SourceIntel(file_name='test.py', python_source_code='print("hello")')
+
+        assert intel.python_source_code == 'print("hello")'

django_spire/contrib/seeding/tests/test_override.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.test import TestCase
+
+from django_spire.contrib.seeding.field.override import FieldOverride
+
+
+class TestFieldOverride(TestCase):
+    def setUp(self) -> None:
+        self.seeder_class = MagicMock()
+        self.seeder_class.seed.return_value = [{'name': 'test'}]
+
+    def test_filter_returns_self(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        result = override.filter(name='test')
+
+        assert result is override
+
+    def test_filter_updates_overrides(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        override.filter(name='test', status='active')
+
+        assert override.overrides == {'name': 'test', 'status': 'active'}
+
+    def test_getattr_delegates_to_seeder_class(self) -> None:
+        self.seeder_class.some_attribute = 'value'
+        override = FieldOverride(self.seeder_class)
+
+        result = override.some_attribute
+
+        assert result == 'value'
+
+    def test_init_sets_seeder_class(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        assert override.seeder_class is self.seeder_class
+
+    def test_init_sets_empty_overrides(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        assert override.overrides == {}
+
+    def test_seed_calls_seeder_class_seed(self) -> None:
+        override = FieldOverride(self.seeder_class)
+        override.filter(name='override_value')
+
+        override.seed(count=2)
+
+        self.seeder_class.seed.assert_called_once_with(
+            count=2,
+            fields={'name': 'override_value'}
+        )
+
+    def test_seed_returns_seeder_class_result(self) -> None:
+        override = FieldOverride(self.seeder_class)
+
+        result = override.seed(count=1)
+
+        assert result == [{'name': 'test'}]

django_spire/contrib/service/__init__.py

@@ -1,7 +1,7 @@
-from django_spire.contrib.service.exceptions import ServiceException
+from django_spire.contrib.service.exceptions import ServiceError
 from django_spire.contrib.service.django_model_service import BaseDjangoModelService
 
 __all__ = [
     'BaseDjangoModelService',
-    'ServiceException',
+    'ServiceError',
 ]

django_spire/contrib/service/django_model_service.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 
 import logging
+
 from abc import ABC
-from typing import Type, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from django.db import transaction
 from django.db.models import Model
 
 from django_spire.contrib.constructor.django_model_constructor import BaseDjangoModelConstructor
-from django_spire.contrib.service.exceptions import ServiceException
+from django_spire.contrib.service.exceptions import ServiceError
+
+
+log = logging.getLogger(__name__)
 
-TypeDjangoModel = TypeVar('TypeDjangoModel', bound=Model, covariant=True)
+TypeDjangoModel_co = TypeVar('TypeDjangoModel_co', bound=Model, covariant=True)
 
 
 class BaseDjangoModelService(
-    BaseDjangoModelConstructor[TypeDjangoModel],
+    BaseDjangoModelConstructor[TypeDjangoModel_co],
     ABC,
-    Generic[TypeDjangoModel]
+    Generic[TypeDjangoModel_co]
 ):
     def _get_concrete_fields(self) -> dict:
         return {
@@ -33,7 +37,7 @@ class BaseDjangoModelService(
 
         for field, value in field_data.items():
             if field not in allowed:
-                logging.warning(f'Field {field!r} is not valid for {self.obj.__class__.__name__}')
+                log.warning(f'Field {field!r} is not valid for {self.obj.__class__.__name__}')
                 continue
 
             model_field = concrete_fields.get(field.removesuffix("_id"), None)
@@ -51,12 +55,8 @@ class BaseDjangoModelService(
         concrete_fields = self._get_concrete_fields()
         touched_fields = self._get_touched_fields(concrete_fields, **field_data)
 
-        try:
-            self.obj.full_clean(
-                exclude=[field for field in concrete_fields if field not in touched_fields]
-            )
-        except:
-            raise
+        exclude = [field for field in concrete_fields if field not in touched_fields]
+        self.obj.full_clean(exclude=exclude)
 
         return touched_fields
 
@@ -65,7 +65,8 @@ class BaseDjangoModelService(
         new_model_obj_was_created = False
 
         if not field_data:
-            raise ServiceException(f'Field data is required to save on {self.obj.__class__.__name__}')
+            message = f'Field data is required to save on {self.obj.__class__.__name__}'
+            raise ServiceError(message)
 
         touched_fields = self.validate_model_obj(**field_data)
 
@@ -77,7 +78,7 @@ class BaseDjangoModelService(
             self.obj.save(update_fields=touched_fields)
 
         else:
-            logging.warning(
-                f'{self.obj.__class__.__name__} is not a new object or there was no touched fields to update.')
+            message = f'{self.obj.__class__.__name__} is not a new object or there was no touched fields to update.'
+            log.warning(message)
 
         return self.obj, new_model_obj_was_created

django_spire/contrib/service/exceptions.py

@@ -1,5 +1,7 @@
-from django_spire.exceptions import DjangoSpireException
+from __future__ import annotations
 
+from django_spire.exceptions import DjangoSpireError
 
-class ServiceException(DjangoSpireException):
-    pass
+
+class ServiceError(DjangoSpireError):
+    pass

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))