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

django_spire/contrib/breadcrumb/breadcrumbs.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TypedDict
+from typing import Any, TypedDict
 
 
 class BreadcrumbDict(TypedDict):
@@ -9,7 +9,7 @@ class BreadcrumbDict(TypedDict):
 
 
 class BreadcrumbItem:
-    def __init__(self, name: str, href: str | None = None):
+    def __init__(self, name: str, href: str | None = None) -> None:
         self.name = name
         self.href = href
 
@@ -18,21 +18,18 @@ class BreadcrumbItem:
 
 
 class Breadcrumbs:
-    def __init__(self, branch_slug: str | None = None):
+    def __init__(self) -> None:
         self.data: list[BreadcrumbItem] = []
         self.index: int = 0
 
-    def __add__(self, other):
+    def __add__(self, other: Breadcrumbs) -> Breadcrumbs:
         self.data += other.data
         return self
 
-    def __iter__(self):
+    def __iter__(self) -> Breadcrumbs:
         self.index = 0
         return self
 
-    def __str__(self) -> str:
-        return str(self.data)
-
     def __len__(self) -> int:
         return len(self.data)
 
@@ -44,7 +41,10 @@ class Breadcrumbs:
         self.index += 1
         return breadcrumb_item.to_dict()
 
-    def add_base_breadcrumb(self, model) -> None:
+    def __str__(self) -> str:
+        return str(self.data)
+
+    def add_base_breadcrumb(self, model: Any) -> None:
         if hasattr(model, 'base_breadcrumb'):
             self += model.base_breadcrumb()
 
@@ -52,13 +52,7 @@ class Breadcrumbs:
         breadcrumb_item = BreadcrumbItem(name=name, href=href)
         self.data.append(breadcrumb_item)
 
-    def add_obj_breadcrumbs(self, obj) -> None:
-        # Expects a breadcrumb object to be returned from the object
-        if hasattr(obj, 'breadcrumbs'):
-            object_breadcrumbs = obj.breadcrumbs()
-            self.data += object_breadcrumbs.data
-
-    def add_form_breadcrumbs(self, obj) -> None:
+    def add_form_breadcrumbs(self, obj: Any) -> None:
         self.add_obj_breadcrumbs(obj)
 
         if obj.pk is None:
@@ -67,10 +61,16 @@ class Breadcrumbs:
         else:
             self.add_breadcrumb(name='Edit')
 
-    def remove(self, index: int):
+    def add_obj_breadcrumbs(self, obj: Any) -> None:
+        # It expects a breadcrumb object to be returned from the object
+        if hasattr(obj, 'breadcrumbs'):
+            object_breadcrumbs = obj.breadcrumbs()
+            self.data += object_breadcrumbs.data
+
+    def remove(self, index: int) -> Breadcrumbs:
         del self.data[index]
         return self
 
-    def reverse(self):
+    def reverse(self) -> Breadcrumbs:
         self.data.reverse()
         return self

django_spire/contrib/breadcrumb/tests/test_breadcrumbs.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.test import TestCase
+
+from django_spire.contrib.breadcrumb.breadcrumbs import BreadcrumbItem, Breadcrumbs
+
+
+class TestBreadcrumbItem(TestCase):
+    def test_create_with_href(self) -> None:
+        item = BreadcrumbItem(name='Home', href='/home/')
+
+        assert item.name == 'Home'
+        assert item.href == '/home/'
+
+    def test_create_without_href(self) -> None:
+        item = BreadcrumbItem(name='Current Page')
+
+        assert item.name == 'Current Page'
+        assert item.href is None
+
+    def test_to_dict(self) -> None:
+        item = BreadcrumbItem(name='Home', href='/home/')
+        result = item.to_dict()
+
+        assert result == {'name': 'Home', 'href': '/home/'}
+
+    def test_to_dict_without_href(self) -> None:
+        item = BreadcrumbItem(name='Current Page')
+        result = item.to_dict()
+
+        assert result == {'name': 'Current Page', 'href': None}
+
+
+class TestBreadcrumbs(TestCase):
+    def test_add_base_breadcrumb(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        model = MagicMock()
+        model_breadcrumbs = Breadcrumbs()
+        model_breadcrumbs.add_breadcrumb('Base', '/base/')
+        model.base_breadcrumb.return_value = model_breadcrumbs
+
+        breadcrumbs.add_base_breadcrumb(model)
+
+        assert len(breadcrumbs) == 1
+
+    def test_add_base_breadcrumb_no_method(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        model = MagicMock(spec=[])
+
+        breadcrumbs.add_base_breadcrumb(model)
+
+        assert len(breadcrumbs) == 0
+
+    def test_add_breadcrumb(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('Home', '/home/')
+
+        assert len(breadcrumbs) == 1
+        assert breadcrumbs.data[0].name == 'Home'
+        assert breadcrumbs.data[0].href == '/home/'
+
+    def test_add_breadcrumb_without_href(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('Current Page')
+
+        assert len(breadcrumbs) == 1
+        assert breadcrumbs.data[0].name == 'Current Page'
+        assert breadcrumbs.data[0].href is None
+
+    def test_add_form_breadcrumbs_create(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        obj = MagicMock()
+        obj.pk = None
+        obj._meta.model._meta.verbose_name = 'Test Model'
+        del obj.breadcrumbs
+
+        breadcrumbs.add_form_breadcrumbs(obj)
+
+        assert len(breadcrumbs) == 2
+        assert breadcrumbs.data[0].name == 'Test Model'
+        assert breadcrumbs.data[1].name == 'Create'
+
+    def test_add_form_breadcrumbs_edit(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        obj = MagicMock()
+        obj.pk = 1
+        del obj.breadcrumbs
+
+        breadcrumbs.add_form_breadcrumbs(obj)
+
+        assert len(breadcrumbs) == 1
+        assert breadcrumbs.data[0].name == 'Edit'
+
+    def test_add_obj_breadcrumbs(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        obj_breadcrumbs = Breadcrumbs()
+        obj_breadcrumbs.add_breadcrumb('Object', '/object/')
+
+        obj = MagicMock()
+        obj.breadcrumbs.return_value = obj_breadcrumbs
+
+        breadcrumbs.add_obj_breadcrumbs(obj)
+
+        assert len(breadcrumbs) == 1
+        assert breadcrumbs.data[0].name == 'Object'
+
+    def test_add_obj_breadcrumbs_no_method(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        obj = MagicMock(spec=[])
+
+        breadcrumbs.add_obj_breadcrumbs(obj)
+
+        assert len(breadcrumbs) == 0
+
+    def test_add_operator(self) -> None:
+        breadcrumbs1 = Breadcrumbs()
+        breadcrumbs1.add_breadcrumb('Home', '/home/')
+
+        breadcrumbs2 = Breadcrumbs()
+        breadcrumbs2.add_breadcrumb('Page', '/page/')
+
+        result = breadcrumbs1 + breadcrumbs2
+
+        assert len(result) == 2
+        assert result.data[0].name == 'Home'
+        assert result.data[1].name == 'Page'
+
+    def test_empty_breadcrumbs(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        assert len(breadcrumbs) == 0
+
+    def test_iteration(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('Home', '/home/')
+        breadcrumbs.add_breadcrumb('Page', '/page/')
+
+        items = list(breadcrumbs)
+
+        assert len(items) == 2
+        assert items[0] == {'name': 'Home', 'href': '/home/'}
+        assert items[1] == {'name': 'Page', 'href': '/page/'}
+
+    def test_iteration_empty(self) -> None:
+        breadcrumbs = Breadcrumbs()
+
+        items = list(breadcrumbs)
+
+        assert items == []
+
+    def test_len(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('Home', '/home/')
+        breadcrumbs.add_breadcrumb('Page', '/page/')
+
+        assert len(breadcrumbs) == 2
+
+    def test_remove(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('Home', '/home/')
+        breadcrumbs.add_breadcrumb('Page', '/page/')
+        breadcrumbs.add_breadcrumb('Current', None)
+
+        result = breadcrumbs.remove(1)
+
+        assert len(breadcrumbs) == 2
+        assert breadcrumbs.data[0].name == 'Home'
+        assert breadcrumbs.data[1].name == 'Current'
+        assert result is breadcrumbs
+
+    def test_reverse(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('First', '/first/')
+        breadcrumbs.add_breadcrumb('Second', '/second/')
+        breadcrumbs.add_breadcrumb('Third', '/third/')
+
+        result = breadcrumbs.reverse()
+
+        assert breadcrumbs.data[0].name == 'Third'
+        assert breadcrumbs.data[1].name == 'Second'
+        assert breadcrumbs.data[2].name == 'First'
+        assert result is breadcrumbs
+
+    def test_str(self) -> None:
+        breadcrumbs = Breadcrumbs()
+        breadcrumbs.add_breadcrumb('Home', '/home/')
+
+        result = str(breadcrumbs)
+
+        assert 'BreadcrumbItem' in result or '[' in result

django_spire/contrib/constructor/__init__.py

@@ -1,9 +1,9 @@
-from django_spire.contrib.constructor.exceptions import ConstructorException
+from django_spire.contrib.constructor.exceptions import ConstructorError
 from django_spire.contrib.constructor.django_model_constructor import BaseDjangoModelConstructor
 from django_spire.contrib.constructor.constructor import BaseConstructor
 
 __all__ = [
     'BaseConstructor',
     'BaseDjangoModelConstructor',
-    'ConstructorException'
-]
+    'ConstructorError'
+]

django_spire/contrib/constructor/constructor.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from abc import ABC
 from typing import Any, Generic, TypeVar
 
-from django_spire.contrib.constructor.exceptions import ConstructorException
+from django_spire.contrib.constructor.exceptions import ConstructorError
 
 
 TypeAny = TypeVar('TypeAny', bound=Any, covariant=True)
@@ -15,7 +15,7 @@ class BaseConstructor(
 ):
     def __init__(self, obj: Any = None):
         self._obj_type_name: str = str(
-            list(self.__class__.__annotations__.values())[0]
+            next(iter(self.__class__.__annotations__.values()))
         ).split('.')[-1]
 
         if obj is None:
@@ -23,22 +23,22 @@ class BaseConstructor(
 
         self._obj_mro_type_names = [cls.__name__ for cls in obj.__class__.__mro__]
 
-        if not self._obj_type_name in self._obj_mro_type_names:
-            raise ConstructorException(
-                f'{self.__class__.__name__} was instantiated with obj type "{obj.__class__.__name__}" and failed as it was expecting "{self._obj_type_name}".'
-            )
+        if self._obj_type_name not in self._obj_mro_type_names:
+            message = f'{self.__class__.__name__} was instantiated with obj type "{obj.__class__.__name__}" and failed as it was expecting "{self._obj_type_name}".'
+            raise ConstructorError(message)
 
         self._obj_type: type[TypeAny] = obj.__class__
 
         if self._obj_type is None or self._obj_type is ...:
-            raise ConstructorException(
-                f'{self.__class__.__name__} top class attribute must have an annotated type.')
+            message = f'{self.__class__.__name__} top class attribute must have an annotated type.'
+            raise ConstructorError(message)
 
         self.obj: TypeAny = obj
 
         if ABC not in self.__class__.__bases__:
             if not self._obj_is_valid:
-                raise ConstructorException(f'{self._obj_type_name} failed to validate on {self.__class__.__name__}')
+                message = f'{self._obj_type_name} failed to validate on {self.__class__.__name__}'
+                raise ConstructorError(message)
 
         self.__post_init__()
 
@@ -47,8 +47,8 @@ class BaseConstructor(
 
         if ABC not in cls.__bases__:
             if 'obj' not in cls.__annotations__:
-                raise ConstructorException(
-                    f'{cls.__name__} must have an "obj" attribute annotated with a type.')
+                message = f'{cls.__name__} must have an "obj" attribute annotated with a type.'
+                raise ConstructorError(message)
 
             # Typing Does not work properly for services if you override __get__ in the BaseService class.
             # This is a workaround and should be fixed in future versions of the python lsp.
@@ -63,11 +63,11 @@ class BaseConstructor(
 
                     self._validate_base_service_target_or_error(target)
 
-                    return cls(getattr(target, 'obj'))
+                    return cls(target.obj)
 
                 return cls(target)
 
-            setattr(cls, '__get__', __get__)
+            cls.__get__ = __get__
 
     def __post_init__(self):
         pass
@@ -82,5 +82,5 @@ class BaseConstructor(
 
     def _validate_base_service_target_or_error(self, target: BaseConstructor):
         if self._obj_type_name not in target._obj_mro_type_names:
-            raise ConstructorException(
-                f'{target.__class__.__name__} must use the same obj type as {self.__class__.__name__}. {self._obj_type_name} is not in {target._obj_mro_type_names}')
+            message = f'{target.__class__.__name__} must use the same obj type as {self.__class__.__name__}. {self._obj_type_name} is not in {target._obj_mro_type_names}'
+            raise ConstructorError(message)

django_spire/contrib/constructor/django_model_constructor.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Type, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from django.db.models import Model
 
 from django_spire.contrib.constructor.constructor import BaseConstructor
 
+
 TypeDjangoModel = TypeVar('TypeDjangoModel', bound=Model, covariant=True)
 
 
@@ -17,11 +18,11 @@ class BaseDjangoModelConstructor(
 ):
     @property
     def _model_obj_id_is_empty(self) -> bool:
-        return self.obj.id is None or self.obj.id == 0 or self.obj.id == ''
+        return self.obj.id is None or self.obj.id in {0, ''}
 
     @property
     def _model_obj_pk_is_empty(self) -> bool:
-        return self.obj.pk is None or self.obj.pk == 0 or self.obj.pk == ''
+        return self.obj.pk is None or self.obj.pk in {0, ''}
 
     @property
     def model_obj_is_created(self) -> bool:
@@ -32,7 +33,7 @@ class BaseDjangoModelConstructor(
         return self._model_obj_id_is_empty or self._model_obj_pk_is_empty
 
     @property
-    def obj_class(self) -> Type[TypeDjangoModel]:
+    def obj_class(self) -> type[TypeDjangoModel]:
         return super().obj_class
 
     @property

django_spire/contrib/constructor/exceptions.py

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

django_spire/contrib/constructor/tests/test_constructor.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import pytest
+
+from abc import ABC
+
+from django.contrib.auth.models import User
+from django.test import TestCase
+
+from django_spire.contrib.constructor import (
+    BaseConstructor,
+    BaseDjangoModelConstructor,
+    ConstructorError,
+)
+
+
+class TestBaseConstructor(TestCase):
+    def test_abc_subclass_does_not_require_obj_annotation(self) -> None:
+        class AbstractConstructor(BaseConstructor, ABC):
+            pass
+
+        # Should not raise
+        assert AbstractConstructor is not None
+
+    def test_constructor_with_none_obj(self) -> None:
+        class StringConstructor(BaseConstructor[str]):
+            obj: str
+
+        constructor = StringConstructor(None)
+
+        assert not hasattr(constructor, 'obj')
+
+    def test_constructor_with_valid_obj(self) -> None:
+        class StringConstructor(BaseConstructor[str]):
+            obj: str
+
+        constructor = StringConstructor('test')
+
+        assert constructor.obj == 'test'
+
+    def test_constructor_with_wrong_type_raises_error(self) -> None:
+        class StringConstructor(BaseConstructor[str]):
+            obj: str
+
+        with pytest.raises(ConstructorError):
+            StringConstructor(123)
+
+    def test_obj_class_property(self) -> None:
+        class StringConstructor(BaseConstructor[str]):
+            obj: str
+
+        constructor = StringConstructor('test')
+
+        assert constructor.obj_class is str
+
+    def test_obj_is_valid_property(self) -> None:
+        class StringConstructor(BaseConstructor[str]):
+            obj: str
+
+        constructor = StringConstructor('test')
+
+        assert constructor._obj_is_valid is True
+
+    def test_post_init_called(self) -> None:
+        class StringConstructor(BaseConstructor[str]):
+            obj: str
+            post_init_called: bool = False
+
+            def __post_init__(self):
+                self.post_init_called = True
+
+        constructor = StringConstructor('test')
+
+        assert constructor.post_init_called is True
+
+    def test_subclass_without_obj_annotation_raises_error(self) -> None:
+        with pytest.raises(ConstructorError, match='must have an "obj" attribute'):
+            class InvalidConstructor(BaseConstructor[str]):
+                pass
+
+
+class TestBaseDjangoModelConstructor(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+
+    def test_constructor_with_django_model(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor.obj == self.user
+
+    def test_model_obj_is_created_true(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor.model_obj_is_created is True
+
+    def test_model_obj_is_created_false_for_new(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        new_user = User(username='newuser')
+        constructor = UserConstructor(new_user)
+
+        assert constructor.model_obj_is_created is False
+
+    def test_model_obj_is_new_false(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor.model_obj_is_new is False
+
+    def test_model_obj_is_new_true(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        new_user = User(username='newuser')
+        constructor = UserConstructor(new_user)
+
+        assert constructor.model_obj_is_new is True
+
+    def test_model_obj_pk_is_empty_true(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        new_user = User(username='newuser')
+        constructor = UserConstructor(new_user)
+
+        assert constructor._model_obj_pk_is_empty is True
+
+    def test_model_obj_pk_is_empty_false(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor._model_obj_pk_is_empty is False
+
+    def test_obj_class_returns_model_class(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor.obj_class is User
+
+    def test_obj_is_valid_true(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor._obj_is_valid is True
+
+
+class TestConstructorError(TestCase):
+    def test_constructor_error_is_exception(self) -> None:
+        assert issubclass(ConstructorError, Exception)
+
+    def test_constructor_error_message(self) -> None:
+        error = ConstructorError('Test error message')
+
+        assert str(error) == 'Test error message'
+
+    def test_constructor_error_can_be_raised(self) -> None:
+        with pytest.raises(ConstructorError):
+            message = 'Test'
+            raise ConstructorError(message)
+
+
+class TestConstructorDescriptor(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+
+    def test_descriptor_get_from_model_instance(self) -> None:
+        class UserConstructor(BaseDjangoModelConstructor[User]):
+            obj: User
+
+        constructor = UserConstructor(self.user)
+
+        assert constructor.obj == self.user