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

django_spire/notification/tests/factories.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import User
+
+from django_spire.notification.choices import (
+    NotificationPriorityChoices,
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.models import Notification
+
+
+def create_test_notification(**kwargs) -> Notification:
+    if 'user' not in kwargs:
+        kwargs['user'] = User.objects.first()
+
+    data = {
+        'type': NotificationTypeChoices.APP,
+        'title': 'Test Notification',
+        'body': 'This is a test notification body.',
+        'url': 'https://example.com',
+        'status': NotificationStatusChoices.PENDING,
+        'priority': NotificationPriorityChoices.LOW,
+    }
+    data.update(kwargs)
+    return Notification.objects.create(**data)

django_spire/notification/tests/test_admin.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from django.contrib.admin.sites import AdminSite
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.admin import NotificationAdmin
+from django_spire.notification.models import Notification
+from django_spire.notification.tests.factories import create_test_notification
+
+
+class NotificationAdminTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.site = AdminSite()
+        self.admin = NotificationAdmin(Notification, self.site)
+        self.notification = create_test_notification()
+
+    def test_list_display(self):
+        expected = (
+            'id', 'title', 'type', 'user', 'view_body_snippet', 'url_link', 'status',
+            'status_message', 'priority', 'sent_datetime', 'publish_datetime',
+            'content_type', 'object_id', 'is_deleted'
+        )
+        assert self.admin.list_display == expected
+
+    def test_list_filter(self):
+        expected = ('type',)
+        assert self.admin.list_filter == expected
+
+    def test_search_fields(self):
+        expected = ('id', 'title', 'type')
+        assert self.admin.search_fields == expected
+
+    def test_view_body_snippet_truncates_long_body(self):
+        self.notification.body = 'A' * 50
+        result = self.admin.view_body_snippet(self.notification)
+        assert len(result) <= 23
+        assert result.endswith('...')
+
+    def test_view_body_snippet_short_body(self):
+        self.notification.body = 'Short'
+        result = self.admin.view_body_snippet(self.notification)
+        assert result == 'Short'
+
+    def test_url_link_with_url(self):
+        self.notification.url = 'https://example.com'
+        result = self.admin.url_link(self.notification)
+        assert 'href="https://example.com"' in result
+        assert 'Link' in result
+
+    def test_url_link_without_url(self):
+        self.notification.url = ''
+        result = self.admin.url_link(self.notification)
+        assert result == 'No URL'

django_spire/notification/tests/test_apps.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from django.apps import apps
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.apps import NotificationConfig
+
+
+class NotificationConfigTests(BaseTestCase):
+    def test_app_name(self):
+        assert NotificationConfig.name == 'django_spire.notification'
+
+    def test_app_label(self):
+        assert NotificationConfig.label == 'django_spire_notification'
+
+    def test_default_auto_field(self):
+        assert NotificationConfig.default_auto_field == 'django.db.models.BigAutoField'
+
+    def test_required_apps(self):
+        expected = ('django_spire_core', 'django_spire_history', 'django_spire_history_viewed')
+        assert expected == NotificationConfig.REQUIRED_APPS
+
+    def test_urlpatterns_include(self):
+        assert NotificationConfig.URLPATTERNS_INCLUDE == 'django_spire.notification.urls'
+
+    def test_urlpatterns_namespace(self):
+        assert NotificationConfig.URLPATTERNS_NAMESPACE == 'notification'
+
+    def test_app_is_installed(self):
+        assert apps.is_installed('django_spire.notification')

django_spire/notification/tests/test_automation.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.automations import process_notifications
+
+
+class NotificationAutomationsTests(BaseTestCase):
+    @patch('django_spire.notification.automations.NotificationManager')
+    def test_process_notifications_calls_manager(self, mock_manager_class: MagicMock):
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        result = process_notifications()
+
+        mock_manager.process_ready_notifications.assert_called_once()
+        assert result == 'Successfully Completed'

django_spire/notification/tests/test_choices.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.choices import (
+    NotificationPriorityChoices,
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+
+
+class NotificationTypeChoicesTests(BaseTestCase):
+    def test_app_value(self):
+        assert NotificationTypeChoices.APP == 'app'
+
+    def test_email_value(self):
+        assert NotificationTypeChoices.EMAIL == 'email'
+
+    def test_push_value(self):
+        assert NotificationTypeChoices.PUSH == 'push'
+
+    def test_sms_value(self):
+        assert NotificationTypeChoices.SMS == 'sms'
+
+    def test_choices_count(self):
+        assert len(NotificationTypeChoices.choices) == 4
+
+
+class NotificationStatusChoicesTests(BaseTestCase):
+    def test_pending_value(self):
+        assert NotificationStatusChoices.PENDING == 'pending'
+
+    def test_processing_value(self):
+        assert NotificationStatusChoices.PROCESSING == 'processing'
+
+    def test_sent_value(self):
+        assert NotificationStatusChoices.SENT == 'sent'
+
+    def test_errored_value(self):
+        assert NotificationStatusChoices.ERRORED == 'errored'
+
+    def test_failed_value(self):
+        assert NotificationStatusChoices.FAILED == 'failed'
+
+    def test_choices_count(self):
+        assert len(NotificationStatusChoices.choices) == 5
+
+
+class NotificationPriorityChoicesTests(BaseTestCase):
+    def test_low_value(self):
+        assert NotificationPriorityChoices.LOW == 'low'
+
+    def test_medium_value(self):
+        assert NotificationPriorityChoices.MEDIUM == 'medium'
+
+    def test_high_value(self):
+        assert NotificationPriorityChoices.HIGH == 'high'
+
+    def test_choices_count(self):
+        assert len(NotificationPriorityChoices.choices) == 3

django_spire/notification/tests/test_exceptions.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.exceptions import DjangoSpireError
+from django_spire.notification.app.exceptions import AppNotificationError
+from django_spire.notification.email.exceptions import EmailNotificationError
+from django_spire.notification.exceptions import NotificationError
+from django_spire.notification.sms.exceptions import (
+    SmsNotificationError,
+    SmsTemporaryMediaError,
+    TwilioAPIConcurrentError,
+    TwilioError,
+)
+
+
+class NotificationExceptionsTests(BaseTestCase):
+    def test_notification_error_is_django_spire_error(self):
+        assert issubclass(NotificationError, DjangoSpireError)
+
+    def test_notification_error_message(self):
+        error = NotificationError('Test error')
+        assert str(error) == 'Test error'
+
+
+class AppNotificationExceptionsTests(BaseTestCase):
+    def test_app_notification_error_is_django_spire_error(self):
+        assert issubclass(AppNotificationError, DjangoSpireError)
+
+    def test_app_notification_error_message(self):
+        error = AppNotificationError('Test error')
+        assert str(error) == 'Test error'
+
+
+class EmailNotificationExceptionsTests(BaseTestCase):
+    def test_email_notification_error_is_django_spire_error(self):
+        assert issubclass(EmailNotificationError, DjangoSpireError)
+
+    def test_email_notification_error_message(self):
+        error = EmailNotificationError('Test error')
+        assert str(error) == 'Test error'
+
+
+class SmsNotificationExceptionsTests(BaseTestCase):
+    def test_sms_notification_error_is_django_spire_error(self):
+        assert issubclass(SmsNotificationError, DjangoSpireError)
+
+    def test_sms_notification_error_message(self):
+        error = SmsNotificationError('Test error')
+        assert str(error) == 'Test error'
+
+    def test_sms_temporary_media_error_is_sms_notification_error(self):
+        assert issubclass(SmsTemporaryMediaError, SmsNotificationError)
+
+    def test_twilio_error_is_exception(self):
+        assert issubclass(TwilioError, Exception)
+
+    def test_twilio_api_concurrent_error_is_twilio_error(self):
+        assert issubclass(TwilioAPIConcurrentError, TwilioError)

django_spire/notification/tests/test_managers.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.managers import NotificationManager
+
+
+class NotificationManagerTests(BaseTestCase):
+    @patch('django_spire.notification.managers.NotificationProcessor')
+    def test_process_ready_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_ready_notifications()
+
+        mock_processor.process_ready.assert_called_once()
+
+    @patch('django_spire.notification.managers.NotificationProcessor')
+    def test_process_errored_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_errored_notifications()
+
+        mock_processor.process_errored.assert_called_once()
+
+    @patch('django_spire.notification.managers.AppNotificationProcessor')
+    def test_process_ready_app_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_ready_app_notifications()
+
+        mock_processor.process_ready.assert_called_once()
+
+    @patch('django_spire.notification.managers.AppNotificationProcessor')
+    def test_process_errored_app_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_errored_app_notifications()
+
+        mock_processor.process_errored.assert_called_once()
+
+    @patch('django_spire.notification.managers.EmailNotificationProcessor')
+    def test_process_ready_email_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_ready_email_notifications()
+
+        mock_processor.process_ready.assert_called_once()
+
+    @patch('django_spire.notification.managers.EmailNotificationProcessor')
+    def test_process_errored_email_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_errored_email_notifications()
+
+        mock_processor.process_errored.assert_called_once()
+
+    @patch('django_spire.notification.managers.SMSNotificationProcessor')
+    def test_process_ready_sms_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_ready_sms_notifications()
+
+        mock_processor.process_ready.assert_called_once()
+
+    @patch('django_spire.notification.managers.SMSNotificationProcessor')
+    def test_process_errored_sms_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+
+        NotificationManager.process_errored_sms_notifications()
+
+        mock_processor.process_errored.assert_called_once()
+
+    @patch('django_spire.notification.managers.NotificationProcessor')
+    def test_process_notification(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+        mock_notification = MagicMock()
+
+        NotificationManager.process_notification(mock_notification)
+
+        mock_processor.process.assert_called_once_with(mock_notification)
+
+    @patch('django_spire.notification.managers.NotificationProcessor')
+    def test_process_notifications(self, mock_processor_class: MagicMock):
+        mock_processor = MagicMock()
+        mock_processor_class.return_value = mock_processor
+        mock_notifications = [MagicMock(), MagicMock()]
+
+        NotificationManager.process_notifications(mock_notifications)
+
+        mock_processor.process_list.assert_called_once_with(mock_notifications)

django_spire/notification/tests/test_maps.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.app.models import AppNotification
+from django_spire.notification.choices import NotificationTypeChoices
+from django_spire.notification.email.models import EmailNotification
+from django_spire.notification.maps import NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP
+from django_spire.notification.push.models import PushNotification
+from django_spire.notification.sms.models import SmsNotification
+
+
+class NotificationMapsTests(BaseTestCase):
+    def test_map_contains_app(self):
+        assert NotificationTypeChoices.APP in NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP
+        assert NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP[NotificationTypeChoices.APP] == AppNotification
+
+    def test_map_contains_email(self):
+        assert NotificationTypeChoices.EMAIL in NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP
+        assert NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP[NotificationTypeChoices.EMAIL] == EmailNotification
+
+    def test_map_contains_push(self):
+        assert NotificationTypeChoices.PUSH in NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP
+        assert NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP[NotificationTypeChoices.PUSH] == PushNotification
+
+    def test_map_contains_sms(self):
+        assert NotificationTypeChoices.SMS in NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP
+        assert NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP[NotificationTypeChoices.SMS] == SmsNotification
+
+    def test_map_has_all_notification_types(self):
+        for choice in NotificationTypeChoices:
+            assert choice in NOTIFICATION_TYPE_CHOICE_TO_MODEL_MAP

django_spire/notification/tests/test_models.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.choices import (
+    NotificationPriorityChoices,
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.tests.factories import create_test_notification
+
+
+class NotificationModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.notification = create_test_notification()
+
+    def test_default_status_is_pending(self):
+        assert self.notification.status == NotificationStatusChoices.PENDING
+
+    def test_default_priority_is_low(self):
+        assert self.notification.priority == NotificationPriorityChoices.LOW
+
+    def test_get_type_display(self):
+        self.notification.type = NotificationTypeChoices.APP
+        assert self.notification.get_type_display() == 'App'
+
+        self.notification.type = NotificationTypeChoices.EMAIL
+        assert self.notification.get_type_display() == 'Email'
+
+        self.notification.type = NotificationTypeChoices.SMS
+        assert self.notification.get_type_display() == 'Sms'
+
+        self.notification.type = NotificationTypeChoices.PUSH
+        assert self.notification.get_type_display() == 'Push'
+
+    def test_get_status_display(self):
+        self.notification.status = NotificationStatusChoices.PENDING
+        assert self.notification.get_status_display() == 'Pending'
+
+        self.notification.status = NotificationStatusChoices.PROCESSING
+        assert self.notification.get_status_display() == 'Processing'
+
+        self.notification.status = NotificationStatusChoices.SENT
+        assert self.notification.get_status_display() == 'Sent'
+
+        self.notification.status = NotificationStatusChoices.ERRORED
+        assert self.notification.get_status_display() == 'Errored'
+
+        self.notification.status = NotificationStatusChoices.FAILED
+        assert self.notification.get_status_display() == 'Failed'
+
+    def test_get_priority_display(self):
+        self.notification.priority = NotificationPriorityChoices.LOW
+        assert self.notification.get_priority_display() == 'Low'
+
+        self.notification.priority = NotificationPriorityChoices.MEDIUM
+        assert self.notification.get_priority_display() == 'Medium'
+
+        self.notification.priority = NotificationPriorityChoices.HIGH
+        assert self.notification.get_priority_display() == 'High'
+
+    def test_user_relationship(self):
+        assert self.notification.user is not None
+        assert self.notification.user.pk is not None
+
+    def test_created_datetime_auto_set(self):
+        assert self.notification.created_datetime is not None
+
+    def test_sent_datetime_null_by_default(self):
+        assert self.notification.sent_datetime is None
+
+    def test_content_object_null_by_default(self):
+        assert self.notification.content_object is None
+        assert self.notification.content_type is None
+        assert self.notification.object_id is None

django_spire/notification/tests/test_querysets.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from django.utils.timezone import now, timedelta
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.choices import (
+    NotificationPriorityChoices,
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.models import Notification
+from django_spire.notification.tests.factories import create_test_notification
+
+
+class NotificationQuerySetTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.user = create_user(username='test_notification_user')
+        self.notification = create_test_notification(user=self.user)
+
+    def test_active_returns_non_deleted(self):
+        result = Notification.objects.active()
+        assert self.notification in result
+
+    def test_active_excludes_deleted(self):
+        self.notification.is_deleted = True
+        self.notification.save()
+
+        result = Notification.objects.active()
+        assert self.notification not in result
+
+    def test_by_user(self):
+        other_user = create_user(username='other_user')
+        other_notification = create_test_notification(user=other_user)
+
+        result = Notification.objects.by_user(self.user)
+        assert self.notification in result
+        assert other_notification not in result
+
+    def test_by_users(self):
+        other_user = create_user(username='other_user')
+        other_notification = create_test_notification(user=other_user)
+
+        result = Notification.objects.by_users([self.user, other_user])
+        assert self.notification in result
+        assert other_notification in result
+
+    def test_app_notifications(self):
+        self.notification.type = NotificationTypeChoices.APP
+        self.notification.save()
+
+        email_notification = create_test_notification(
+            user=self.user,
+            type=NotificationTypeChoices.EMAIL
+        )
+
+        result = Notification.objects.app_notifications()
+        assert self.notification in result
+        assert email_notification not in result
+
+    def test_email_notifications(self):
+        self.notification.type = NotificationTypeChoices.EMAIL
+        self.notification.save()
+
+        app_notification = create_test_notification(
+            user=self.user,
+            type=NotificationTypeChoices.APP
+        )
+
+        result = Notification.objects.email_notifications()
+        assert self.notification in result
+        assert app_notification not in result
+
+    def test_sms_notifications(self):
+        self.notification.type = NotificationTypeChoices.SMS
+        self.notification.save()
+
+        result = Notification.objects.sms_notifications()
+        assert self.notification in result
+
+    def test_pending(self):
+        self.notification.status = NotificationStatusChoices.PENDING
+        self.notification.save()
+
+        sent_notification = create_test_notification(
+            user=self.user,
+            status=NotificationStatusChoices.SENT
+        )
+
+        result = Notification.objects.pending()
+        assert self.notification in result
+        assert sent_notification not in result
+
+    def test_processing(self):
+        self.notification.status = NotificationStatusChoices.PROCESSING
+        self.notification.save()
+
+        result = Notification.objects.processing()
+        assert self.notification in result
+
+    def test_sent(self):
+        self.notification.status = NotificationStatusChoices.SENT
+        self.notification.save()
+
+        result = Notification.objects.sent()
+        assert self.notification in result
+
+    def test_errored(self):
+        self.notification.status = NotificationStatusChoices.ERRORED
+        self.notification.save()
+
+        result = Notification.objects.errored()
+        assert self.notification in result
+
+    def test_failed(self):
+        self.notification.status = NotificationStatusChoices.FAILED
+        self.notification.save()
+
+        result = Notification.objects.failed()
+        assert self.notification in result
+
+    def test_unsent(self):
+        pending = create_test_notification(
+            user=self.user,
+            status=NotificationStatusChoices.PENDING
+        )
+        processing = create_test_notification(
+            user=self.user,
+            status=NotificationStatusChoices.PROCESSING
+        )
+        sent = create_test_notification(
+            user=self.user,
+            status=NotificationStatusChoices.SENT
+        )
+
+        result = Notification.objects.unsent()
+        assert pending in result
+        assert processing in result
+        assert sent not in result
+
+    def test_ready_to_send(self):
+        past_notification = create_test_notification(
+            user=self.user,
+            status=NotificationStatusChoices.PENDING,
+            publish_datetime=now() - timedelta(hours=1)
+        )
+        future_notification = create_test_notification(
+            user=self.user,
+            status=NotificationStatusChoices.PENDING,
+            publish_datetime=now() + timedelta(hours=1)
+        )
+
+        result = Notification.objects.ready_to_send()
+        assert past_notification in result
+        assert future_notification not in result
+
+    def test_high_priority(self):
+        self.notification.priority = NotificationPriorityChoices.HIGH
+        self.notification.save()
+
+        low_priority = create_test_notification(
+            user=self.user,
+            priority=NotificationPriorityChoices.LOW
+        )
+
+        result = Notification.objects.high_priority()
+        assert self.notification in result
+        assert low_priority not in result
+
+    def test_medium_priority(self):
+        self.notification.priority = NotificationPriorityChoices.MEDIUM
+        self.notification.save()
+
+        result = Notification.objects.medium_priority()
+        assert self.notification in result
+
+    def test_low_priority(self):
+        self.notification.priority = NotificationPriorityChoices.LOW
+        self.notification.save()
+
+        result = Notification.objects.low_priority()
+        assert self.notification in result

django_spire/notification/tests/test_utils.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.utils import get_throttle_sleep_time
+
+
+class NotificationUtilsTests(BaseTestCase):
+    @override_settings(NOTIFICATION_THROTTLE_RATE_PER_MINUTE=60)
+    def test_get_throttle_sleep_time_60_per_minute(self):
+        result = get_throttle_sleep_time()
+        assert result == 1.0
+
+    @override_settings(NOTIFICATION_THROTTLE_RATE_PER_MINUTE=120)
+    def test_get_throttle_sleep_time_120_per_minute(self):
+        result = get_throttle_sleep_time()
+        assert result == 2.0
+
+    @override_settings(NOTIFICATION_THROTTLE_RATE_PER_MINUTE=30)
+    def test_get_throttle_sleep_time_30_per_minute(self):
+        result = get_throttle_sleep_time()
+        assert result == 0.5

django_spire/notification/urls.py

@@ -1,4 +1,6 @@
-from django.urls import path, include
+from __future__ import annotations
+
+from django.urls import include, path
 
 
 app_name = 'notification'