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

django_spire/history/activity/tests/test_activity.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.contrib.auth.models import User
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+
+from django_spire.history.activity.models import Activity, ActivitySubscriber
+from django_spire.history.activity.utils import add_form_activity
+
+
+class TestActivity(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+        self.recipient = User.objects.create_user(
+            username='recipient',
+            password='testpass'  # noqa: S106
+        )
+        self.content_type = ContentType.objects.get_for_model(User)
+
+    def test_add_subscriber(self) -> None:
+        activity = Activity.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user,
+            verb='created',
+            information='Test information'
+        )
+
+        subscriber = User.objects.create_user(
+            username='subscriber',
+            password='testpass'  # noqa: S106
+        )
+
+        activity.add_subscriber(subscriber)
+
+        assert activity.subscribers.count() == 1
+
+    def test_create_activity(self) -> None:
+        activity = Activity.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user,
+            verb='created',
+            information='Test information'
+        )
+
+        assert activity.pk is not None
+        assert activity.verb == 'created'
+        assert activity.information == 'Test information'
+        assert activity.content_object == self.user
+
+    def test_create_activity_with_recipient(self) -> None:
+        activity = Activity.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user,
+            recipient=self.recipient,
+            verb='assigned',
+            information='Assigned to recipient'
+        )
+
+        assert activity.recipient == self.recipient
+
+    def test_str_representation(self) -> None:
+        activity = Activity.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user,
+            verb='updated'
+        )
+
+        assert 'testuser' in str(activity)
+        assert 'updated' in str(activity)
+
+
+class TestActivitySubscriber(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+        self.subscriber = User.objects.create_user(
+            username='subscriber',
+            password='testpass'  # noqa: S106
+        )
+        self.content_type = ContentType.objects.get_for_model(User)
+        self.activity = Activity.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user,
+            verb='created'
+        )
+
+    def test_create_activity_subscriber(self) -> None:
+        activity_subscriber = ActivitySubscriber.objects.create(
+            activity=self.activity,
+            subscriber=self.subscriber
+        )
+
+        assert activity_subscriber.pk is not None
+        assert activity_subscriber.activity == self.activity
+        assert activity_subscriber.subscriber == self.subscriber
+
+    def test_str_representation(self) -> None:
+        activity_subscriber = ActivitySubscriber.objects.create(
+            activity=self.activity,
+            subscriber=self.subscriber
+        )
+
+        assert str(self.activity) in str(activity_subscriber)
+        assert 'subscriber' in str(activity_subscriber)
+
+
+class TestActivityQuerySet(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+        self.content_type = ContentType.objects.get_for_model(User)
+
+    def test_prefetch_user(self) -> None:
+        Activity.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user,
+            verb='created'
+        )
+
+        activities = Activity.objects.prefetch_user()
+
+        assert activities.count() == 1
+
+
+class TestAddFormActivity(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass',  # noqa: S106
+            first_name='Test',
+            last_name='User'
+        )
+
+    def test_add_form_activity_created(self) -> None:
+        model_object = MagicMock()
+        model_object._meta.verbose_name = 'Test Model'
+        model_object.__str__ = MagicMock(return_value='Test Object')
+        model_object.add_activity = MagicMock()
+
+        add_form_activity(model_object, pk=None, user=self.user)
+
+        model_object.add_activity.assert_called_once()
+        call_kwargs = model_object.add_activity.call_args[1]
+
+        assert call_kwargs['user'] == self.user
+        assert call_kwargs['verb'] == 'updated'
+        assert 'updated' in call_kwargs['information']
+
+    def test_add_form_activity_updated(self) -> None:
+        model_object = MagicMock()
+        model_object._meta.verbose_name = 'Test Model'
+        model_object.__str__ = MagicMock(return_value='Test Object')
+        model_object.add_activity = MagicMock()
+
+        add_form_activity(model_object, pk=1, user=self.user)
+
+        model_object.add_activity.assert_called_once()
+        call_kwargs = model_object.add_activity.call_args[1]
+
+        assert call_kwargs['verb'] == 'created'
+        assert 'created' in call_kwargs['information']

django_spire/history/admin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib import admin
 from django.urls import reverse
 from django.utils.html import format_html
@@ -8,10 +10,15 @@ from django_spire.history import models
 @admin.register(models.HistoryEvent)
 class HistoryEventAdmin(admin.ModelAdmin):
     list_display = (
-        'id', 'content_object_link', 'content_type', 'created_datetime', 'event_verbose'
+        'id',
+        'content_object_link',
+        'content_type',
+        'created_datetime',
+        'event_verbose'
     )
+
     list_filter = ('event', 'created_datetime')
-    search_fields = ('id', 'content_type__model',)
+    search_fields = ('id', 'content_type__model')
     ordering = ('-created_datetime',)
 
     def content_object_link(self, history_event: models.HistoryEvent) -> str:

django_spire/history/choices.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 from django.db import models
 
+
 class HistoryEventChoices(models.TextChoices):
     CREATED = 'crea', 'Created'
     UPDATED = 'upda', 'Updated'

django_spire/history/models.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from django.contrib.auth.models import User
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
@@ -11,12 +10,13 @@ from django_spire.history.choices import HistoryEventChoices
 
 class HistoryEvent(models.Model):
     content_type = models.ForeignKey(
-        ContentType, 
-        related_name='history_events', 
-        related_query_name='history_event', 
-        on_delete=models.CASCADE, 
+        ContentType,
+        related_name='history_events',
+        related_query_name='history_event',
+        on_delete=models.CASCADE,
         editable=False
     )
+
     object_id = models.PositiveIntegerField(editable=False)
     content_object = GenericForeignKey('content_type', 'object_id')
 

django_spire/history/tests/test_admin.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.contrib.admin.sites import AdminSite
+from django.test import TestCase
+
+from django_spire.history.activity.admin import ActivityAdmin
+from django_spire.history.activity.models import Activity
+from django_spire.history.admin import HistoryEventAdmin
+from django_spire.history.models import HistoryEvent
+from django_spire.history.viewed.admin import ViewAdmin
+from django_spire.history.viewed.models import Viewed
+
+
+class TestActivityAdmin(TestCase):
+    def setUp(self) -> None:
+        self.site = AdminSite()
+        self.admin = ActivityAdmin(Activity, self.site)
+
+    def test_information_snippet_long(self) -> None:
+        activity = MagicMock()
+        activity.information = 'This is a very long information string that exceeds twenty characters'
+
+        result = self.admin.information_snippet(activity)
+
+        assert result.endswith('...')
+        assert len(result) == 23
+
+    def test_information_snippet_none(self) -> None:
+        activity = MagicMock()
+        activity.information = None
+
+        result = self.admin.information_snippet(activity)
+
+        assert result == 'No Information'
+
+    def test_information_snippet_short(self) -> None:
+        activity = MagicMock()
+        activity.information = 'Short info'
+
+        result = self.admin.information_snippet(activity)
+
+        assert result == 'Short info'
+
+    def test_list_display(self) -> None:
+        assert 'id' in self.admin.list_display
+        assert 'content_object_link' in self.admin.list_display
+        assert 'verb' in self.admin.list_display
+        assert 'user_link' in self.admin.list_display
+
+    def test_list_filter(self) -> None:
+        assert 'verb' in self.admin.list_filter
+        assert 'created_datetime' in self.admin.list_filter
+
+    def test_recipient_link_no_recipient(self) -> None:
+        activity = MagicMock()
+        activity.recipient = None
+
+        result = self.admin.recipient_link(activity)
+
+        assert result == 'No Recipient'
+
+
+class TestHistoryEventAdmin(TestCase):
+    def setUp(self) -> None:
+        self.site = AdminSite()
+        self.admin = HistoryEventAdmin(HistoryEvent, self.site)
+
+    def test_list_display(self) -> None:
+        assert 'id' in self.admin.list_display
+        assert 'content_object_link' in self.admin.list_display
+        assert 'content_type' in self.admin.list_display
+        assert 'event_verbose' in self.admin.list_display
+
+    def test_list_filter(self) -> None:
+        assert 'event' in self.admin.list_filter
+        assert 'created_datetime' in self.admin.list_filter
+
+
+class TestViewedAdmin(TestCase):
+    def setUp(self) -> None:
+        self.site = AdminSite()
+        self.admin = ViewAdmin(Viewed, self.site)
+
+    def test_list_display(self) -> None:
+        assert 'id' in self.admin.list_display
+        assert 'content_object_link' in self.admin.list_display
+        assert 'user_link' in self.admin.list_display
+        assert 'created_datetime' in self.admin.list_display
+
+    def test_list_filter(self) -> None:
+        assert 'created_datetime' in self.admin.list_filter

django_spire/history/tests/test_history.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import User
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+
+from django_spire.history.choices import HistoryEventChoices
+from django_spire.history.models import HistoryEvent
+from django_spire.history.querysets import HistoryQuerySet
+
+
+class TestHistoryEventChoices(TestCase):
+    def test_active_choice(self) -> None:
+        assert HistoryEventChoices.ACTIVE.value == 'acti'
+        assert HistoryEventChoices.ACTIVE.label == 'Active'
+
+    def test_all_choices_exist(self) -> None:
+        choices = [c[0] for c in HistoryEventChoices.choices]
+
+        assert 'crea' in choices
+        assert 'upda' in choices
+        assert 'acti' in choices
+        assert 'inac' in choices
+        assert 'dele' in choices
+        assert 'unde' in choices
+
+    def test_created_choice(self) -> None:
+        assert HistoryEventChoices.CREATED.value == 'crea'
+        assert HistoryEventChoices.CREATED.label == 'Created'
+
+    def test_deleted_choice(self) -> None:
+        assert HistoryEventChoices.DELETED.value == 'dele'
+        assert HistoryEventChoices.DELETED.label == 'Deleted'
+
+    def test_inactive_choice(self) -> None:
+        assert HistoryEventChoices.INACTIVE.value == 'inac'
+        assert HistoryEventChoices.INACTIVE.label == 'Inactive'
+
+    def test_undeleted_choice(self) -> None:
+        assert HistoryEventChoices.UNDELETED.value == 'unde'
+        assert HistoryEventChoices.UNDELETED.label == 'Un-Deleted'
+
+    def test_updated_choice(self) -> None:
+        assert HistoryEventChoices.UPDATED.value == 'upda'
+        assert HistoryEventChoices.UPDATED.label == 'Updated'
+
+
+class TestHistoryEvent(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+        self.content_type = ContentType.objects.get_for_model(User)
+
+    def test_create_history_event(self) -> None:
+        event = HistoryEvent.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            event=HistoryEventChoices.CREATED
+        )
+
+        assert event.pk is not None
+        assert event.event == 'crea'
+        assert event.content_object == self.user
+
+    def test_event_verbose_property(self) -> None:
+        event = HistoryEvent.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            event=HistoryEventChoices.UPDATED
+        )
+
+        assert event.event_verbose == 'Updated'
+
+    def test_str_representation(self) -> None:
+        event = HistoryEvent.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            event=HistoryEventChoices.CREATED
+        )
+
+        assert 'Created' in str(event)
+
+
+class TestHistoryQuerySet(TestCase):
+    def test_active_filter(self) -> None:
+        # HistoryQuerySet is meant to be used with models that have
+        # is_active and is_deleted fields (via HistoryModelMixin)
+        qs = HistoryQuerySet(model=HistoryEvent)
+
+        # Verify the method exists and returns a QuerySet
+        assert hasattr(qs, 'active')
+
+    def test_deleted_filter(self) -> None:
+        qs = HistoryQuerySet(model=HistoryEvent)
+        assert hasattr(qs, 'deleted')
+
+    def test_inactive_filter(self) -> None:
+        qs = HistoryQuerySet(model=HistoryEvent)
+        assert hasattr(qs, 'inactive')

django_spire/history/tests/test_mixins.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from django.contrib.contenttypes.fields import GenericRelation
+from django.test import TestCase
+
+from django_spire.history.activity.mixins import ActivityMixin
+from django_spire.history.mixins import HistoryModelMixin
+from django_spire.history.viewed.mixins import ViewedModelMixin
+
+
+class TestActivityMixin(TestCase):
+    def test_activities_field_exists(self) -> None:
+        assert hasattr(ActivityMixin, 'activities')
+
+    def test_activities_is_generic_relation(self) -> None:
+        field = ActivityMixin._meta.get_field('activities')
+        assert isinstance(field, GenericRelation)
+
+    def test_add_activity_method_exists(self) -> None:
+        assert hasattr(ActivityMixin, 'add_activity')
+        assert callable(ActivityMixin.add_activity)
+
+    def test_creator_property_exists(self) -> None:
+        assert hasattr(ActivityMixin, 'creator')
+
+    def test_is_abstract(self) -> None:
+        assert ActivityMixin._meta.abstract is True
+
+
+class TestHistoryModelMixin(TestCase):
+    def test_created_datetime_field_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'created_datetime')
+
+    def test_history_events_field_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'history_events')
+
+    def test_history_events_is_generic_relation(self) -> None:
+        field = HistoryModelMixin._meta.get_field('history_events')
+        assert isinstance(field, GenericRelation)
+
+    def test_is_abstract(self) -> None:
+        assert HistoryModelMixin._meta.abstract is True
+
+    def test_is_active_field_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'is_active')
+
+    def test_is_deleted_field_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'is_deleted')
+
+    def test_set_active_method_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'set_active')
+        assert callable(HistoryModelMixin.set_active)
+
+    def test_set_deleted_method_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'set_deleted')
+        assert callable(HistoryModelMixin.set_deleted)
+
+    def test_set_inactive_method_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'set_inactive')
+        assert callable(HistoryModelMixin.set_inactive)
+
+    def test_un_set_deleted_method_exists(self) -> None:
+        assert hasattr(HistoryModelMixin, 'un_set_deleted')
+        assert callable(HistoryModelMixin.un_set_deleted)
+
+
+class TestViewedModelMixin(TestCase):
+    def test_add_view_method_exists(self) -> None:
+        assert hasattr(ViewedModelMixin, 'add_view')
+        assert callable(ViewedModelMixin.add_view)
+
+    def test_is_abstract(self) -> None:
+        assert ViewedModelMixin._meta.abstract is True
+
+    def test_is_viewed_method_exists(self) -> None:
+        assert hasattr(ViewedModelMixin, 'is_viewed')
+        assert callable(ViewedModelMixin.is_viewed)
+
+    def test_views_field_exists(self) -> None:
+        assert hasattr(ViewedModelMixin, 'views')
+
+    def test_views_is_generic_relation(self) -> None:
+        field = ViewedModelMixin._meta.get_field('views')
+        assert isinstance(field, GenericRelation)

django_spire/history/viewed/admin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib import admin
 from django.urls.base import reverse
 from django.utils.html import format_html
@@ -11,7 +13,7 @@ class ViewAdmin(admin.ModelAdmin):
         'id', 'content_object_link', 'user_link', 'created_datetime'
     )
     list_filter = ('created_datetime',)
-    search_fields = ('id', 'user__first_name', 'user__last_name', 'content_type__model',)
+    search_fields = ('id', 'user__first_name', 'user__last_name', 'content_type__model')
     ordering = ('-created_datetime',)
 
     def content_object_link(self, view: Viewed) -> str:

django_spire/history/viewed/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 from django_spire.utils import check_required_apps
@@ -11,4 +13,4 @@ class HistoryViewedConfig(AppConfig):
     REQUIRED_APPS = ('django_spire_core', 'django_spire_history')
 
     def ready(self) -> None:
-        check_required_apps(self.label)
+        check_required_apps(self.label)

django_spire/history/viewed/models.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib.auth.models import User
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType

django_spire/history/viewed/tests/test_viewed.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import User
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+
+from django_spire.history.viewed.models import Viewed
+
+
+class TestViewed(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+        self.content_type = ContentType.objects.get_for_model(User)
+
+    def test_create_viewed(self) -> None:
+        viewed = Viewed.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user
+        )
+
+        assert viewed.pk is not None
+        assert viewed.user == self.user
+        assert viewed.content_object == self.user
+
+    def test_created_datetime_auto_set(self) -> None:
+        viewed = Viewed.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user
+        )
+
+        assert viewed.created_datetime is not None
+
+    def test_str_representation(self) -> None:
+        viewed = Viewed.objects.create(
+            content_type=self.content_type,
+            object_id=self.user.pk,
+            user=self.user
+        )
+
+        assert 'testuser' in str(viewed)
+        assert 'viewed' in str(viewed)