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

django_spire/notification/sms/processor.py

@@ -1,29 +1,35 @@
+from __future__ import annotations
+
 from django.utils.timezone import now
 from django.conf import settings
 
 from twilio.rest import Client
 
-from django_spire.notification.choices import NotificationTypeChoices, \
+from django_spire.notification.choices import (
+    NotificationTypeChoices,
     NotificationStatusChoices
-from django_spire.notification.exceptions import NotificationException
+)
+from django_spire.notification.exceptions import InvalidNotificationTypeError
 from django_spire.notification.models import Notification
 from django_spire.notification.processors.processor import BaseNotificationProcessor
-from django_spire.notification.sms.exceptions import TwilioException, \
-    TwilioAPIConcurrentException
+from django_spire.notification.sms.exceptions import (
+    TwilioAPIConcurrentError,
+    TwilioError
+)
 from django_spire.notification.sms.helper import TwilioSMSHelper, BulkTwilioSMSHelper
 
 
 class SMSNotificationProcessor(BaseNotificationProcessor):
+    def _validate_notification_type(self, notification: Notification):
+        if notification.type != NotificationTypeChoices.SMS:
+            raise InvalidNotificationTypeError(NotificationTypeChoices.SMS, notification.type)
+
     def process(self, notification: Notification):
         notification.status = NotificationStatusChoices.PROCESSING
         notification.save()
 
         try:
-            if notification.type != NotificationTypeChoices.SMS:
-                raise NotificationException(
-                    f'SMSNotificationProcessor only processes '
-                    f'SMS notifications. Was provided {notification.type}'
-                )
+            self._validate_notification_type(notification)
 
             twilio_sms_client = Client(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
             TwilioSMSHelper(notification, twilio_sms_client).send()
@@ -31,35 +37,29 @@ class SMSNotificationProcessor(BaseNotificationProcessor):
             notification.status = NotificationStatusChoices.SENT
             notification.sent_datetime = now()
         except Exception as e:
-            # Requeue notification as api concurrency is full
-            if isinstance(e, TwilioAPIConcurrentException):
+            if isinstance(e, TwilioAPIConcurrentError):
                 notification.status = NotificationStatusChoices.PENDING
                 notification.save()
                 return
 
             notification.status_message = str(e)
 
-            if isinstance(e, TwilioException):
+            if isinstance(e, TwilioError):
                 notification.status = NotificationStatusChoices.ERRORED
             else:
                 notification.status = NotificationStatusChoices.FAILED
-                raise e
+                raise
         finally:
             notification.save()
 
     def process_list(self, notifications: list):
         twilio_sms_client = Client(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
+
         for notification in notifications:
-            if notification.type != NotificationTypeChoices.SMS:
-                raise NotificationException(
-                    f'SMSNotificationProcessor only processes '
-                    f'SMS notifications. Was provided {notification.type}'
-                )
+            self._validate_notification_type(notification)
 
         try:
             BulkTwilioSMSHelper(notifications, twilio_sms_client).send_notifications()
-        except Exception as e:
-            raise e
         finally:
             Notification.objects.bulk_update(
                 notifications,

django_spire/notification/sms/querysets.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django_spire.history.querysets import HistoryQuerySet
 from django_spire.notification.querysets import NotificationContentObjectQuerySet
 

django_spire/notification/sms/tests/factories.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import User
+
+from django_spire.notification.choices import (
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.models import Notification
+from django_spire.notification.sms.models import SmsNotification
+
+
+def create_test_sms_notification(**kwargs) -> SmsNotification:
+    if 'notification' not in kwargs:
+        user = kwargs.pop('user', None) or User.objects.first()
+        notification = Notification.objects.create(
+            user=user,
+            type=NotificationTypeChoices.SMS,
+            title=kwargs.pop('title', 'Test SMS Notification'),
+            body=kwargs.pop('body', 'This is a test SMS notification.'),
+            url=kwargs.pop('url', ''),
+            status=kwargs.pop('status', NotificationStatusChoices.PENDING),
+            priority=kwargs.pop('priority', 'low'),
+        )
+        kwargs['notification'] = notification
+
+    data = {
+        'to_phone_number': '5551234567',
+        'media_url': None,
+        'temporary_media': None,
+    }
+    data.update(kwargs)
+    return SmsNotification.objects.create(**data)

django_spire/notification/sms/tests/test_apps.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from django.apps import apps
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.sms.apps import NotificationSmsConfig
+
+
+class NotificationSmsConfigTests(BaseTestCase):
+    def test_app_name(self):
+        assert NotificationSmsConfig.name == 'django_spire.notification.sms'
+
+    def test_app_label(self):
+        assert NotificationSmsConfig.label == 'django_spire_notification_sms'
+
+    def test_default_auto_field(self):
+        assert NotificationSmsConfig.default_auto_field == 'django.db.models.BigAutoField'
+
+    def test_required_apps(self):
+        expected = ('django_spire_core', 'django_spire_notification')
+        assert expected == NotificationSmsConfig.REQUIRED_APPS
+
+    def test_app_is_installed(self):
+        assert apps.is_installed('django_spire.notification.sms')

django_spire/notification/sms/tests/test_automation.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import uuid
+
+from django.utils.timezone import now, timedelta
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.sms.choices import SmsMediaContentTypeChoices
+from django_spire.notification.sms.models import SmsTemporaryMedia
+
+
+class SmsTemporaryMediaTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.expired_media = SmsTemporaryMedia.objects.create(
+            content='base64content',
+            content_type=SmsMediaContentTypeChoices.PNG,
+            name='expired.png',
+            expire_datetime=now() - timedelta(hours=1),
+            external_access_key=uuid.uuid4(),
+        )
+        self.valid_media = SmsTemporaryMedia.objects.create(
+            content='base64content',
+            content_type=SmsMediaContentTypeChoices.PNG,
+            name='valid.png',
+            expire_datetime=now() + timedelta(hours=1),
+            external_access_key=uuid.uuid4(),
+        )
+
+    def test_is_expired_true(self):
+        assert self.expired_media.is_expired() is True
+
+    def test_is_expired_false(self):
+        assert self.valid_media.is_expired() is False
+
+    def test_external_url_contains_access_key(self):
+        url = self.valid_media.external_url
+        assert str(self.valid_media.external_access_key) in url

django_spire/notification/sms/tests/test_choices.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.sms.choices import SmsMediaContentTypeChoices
+
+
+class SmsMediaContentTypeChoicesTests(BaseTestCase):
+    def test_png_value(self):
+        assert SmsMediaContentTypeChoices.PNG == 'image/png'
+
+    def test_jpeg_value(self):
+        assert SmsMediaContentTypeChoices.JPEG == 'image/jpeg'
+
+    def test_choices_count(self):
+        assert len(SmsMediaContentTypeChoices.choices) == 2

django_spire/notification/sms/tests/test_consts.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.sms.consts import (
+    TWILIO_SMS_BATCH_SIZE_NAME,
+    TWILIO_UNSUCCESSFUL_STATUSES,
+)
+
+
+class SmsConstsTests(BaseTestCase):
+    def test_twilio_unsuccessful_statuses(self):
+        assert 'failed' in TWILIO_UNSUCCESSFUL_STATUSES
+        assert 'undelivered' in TWILIO_UNSUCCESSFUL_STATUSES
+        assert len(TWILIO_UNSUCCESSFUL_STATUSES) == 2
+
+    def test_twilio_sms_batch_size_name(self):
+        assert TWILIO_SMS_BATCH_SIZE_NAME == 'TWILIO_SMS_BATCH_SIZE'

django_spire/notification/sms/tests/test_exceptions.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.sms.exceptions import (
+    SmsNotificationError,
+    SmsTemporaryMediaError,
+    TwilioAPIConcurrentError,
+    TwilioError,
+)
+
+
+class SmsExceptionsTests(BaseTestCase):
+    def test_sms_notification_error_message(self):
+        error = SmsNotificationError('SMS error')
+        assert str(error) == 'SMS error'
+
+    def test_sms_temporary_media_error_message(self):
+        error = SmsTemporaryMediaError('Media error')
+        assert str(error) == 'Media error'
+
+    def test_twilio_error_message(self):
+        error = TwilioError('Twilio error')
+        assert str(error) == 'Twilio error'
+
+    def test_twilio_api_concurrent_error_message(self):
+        error = TwilioAPIConcurrentError('Concurrent error')
+        assert str(error) == 'Concurrent error'

django_spire/notification/sms/tests/test_helper.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.sms.exceptions import TwilioError
+from django_spire.notification.sms.helper import TwilioSMSHelper
+from django_spire.notification.sms.tests.factories import create_test_sms_notification
+
+
+class TwilioSMSHelperTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.user = create_user(username='test_helper_user')
+        self.sms_notification = create_test_sms_notification(user=self.user)
+        self.mock_client = MagicMock()
+
+    def test_format_phone_number_10_digits(self):
+        result = TwilioSMSHelper._format_phone_number('5551234567')
+        assert result == '+15551234567'
+
+    def test_format_phone_number_11_digits_with_country_code(self):
+        result = TwilioSMSHelper._format_phone_number('15551234567')
+        assert result == '+15551234567'
+
+    def test_format_phone_number_invalid_raises_error(self):
+        with pytest.raises(TwilioError):
+            TwilioSMSHelper._format_phone_number('123')
+
+    def test_format_phone_number_too_long_raises_error(self):
+        with pytest.raises(TwilioError):
+            TwilioSMSHelper._format_phone_number('123456789012345')
+
+    def test_message_format(self):
+        helper = TwilioSMSHelper(
+            self.sms_notification.notification,
+            self.mock_client
+        )
+        expected = f'{self.sms_notification.notification.title}: {self.sms_notification.notification.body}'
+        assert helper.message == expected
+
+    def test_to_phone_number_formatted(self):
+        helper = TwilioSMSHelper(
+            self.sms_notification.notification,
+            self.mock_client
+        )
+        assert helper.to_phone_number.startswith('+1')

django_spire/notification/sms/tests/test_models.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import uuid
+
+from django.utils.timezone import now, timedelta
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.models import Notification
+from django_spire.notification.sms.choices import SmsMediaContentTypeChoices
+from django_spire.notification.sms.models import SmsTemporaryMedia
+from django_spire.notification.sms.tests.factories import create_test_sms_notification
+
+
+class SmsNotificationModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.sms_notification = create_test_sms_notification()
+
+    def test_str(self):
+        expected = f'{self.sms_notification.to_phone_number} - {self.sms_notification.notification.title}'
+        assert str(self.sms_notification) == expected
+
+    def test_notification_relationship(self):
+        assert self.sms_notification.notification is not None
+        assert isinstance(self.sms_notification.notification, Notification)
+
+    def test_to_phone_number(self):
+        assert self.sms_notification.to_phone_number == '5551234567'
+
+    def test_media_url_default_none(self):
+        assert self.sms_notification.media_url is None
+
+    def test_temporary_media_default_none(self):
+        assert self.sms_notification.temporary_media is None
+
+    def test_with_media_url(self):
+        sms_notification = create_test_sms_notification(
+            media_url='https://example.com/image.png'
+        )
+        assert sms_notification.media_url == 'https://example.com/image.png'
+
+
+class SmsTemporaryMediaModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.temporary_media = SmsTemporaryMedia.objects.create(
+            content='base64encodedcontent',
+            content_type=SmsMediaContentTypeChoices.PNG,
+            name='test_image.png',
+            expire_datetime=now() + timedelta(hours=1),
+            external_access_key=uuid.uuid4(),
+        )
+
+    def test_str(self):
+        expected = f'{self.temporary_media.name} - {self.temporary_media.content_type}'
+        assert str(self.temporary_media) == expected
+
+    def test_is_expired_false(self):
+        assert self.temporary_media.is_expired() is False
+
+    def test_is_expired_true(self):
+        self.temporary_media.expire_datetime = now() - timedelta(hours=1)
+        self.temporary_media.save()
+        assert self.temporary_media.is_expired() is True
+
+    def test_external_url(self):
+        url = self.temporary_media.external_url
+        assert str(self.temporary_media.external_access_key) in url
+
+    def test_content_type_png(self):
+        assert self.temporary_media.content_type == SmsMediaContentTypeChoices.PNG
+
+    def test_content_type_jpeg(self):
+        media = SmsTemporaryMedia.objects.create(
+            content='base64encodedcontent',
+            content_type=SmsMediaContentTypeChoices.JPEG,
+            name='test_image.jpg',
+            expire_datetime=now() + timedelta(hours=1),
+            external_access_key=uuid.uuid4(),
+        )
+        assert media.content_type == SmsMediaContentTypeChoices.JPEG

django_spire/notification/sms/tests/test_processor.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+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 (
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.exceptions import NotificationError
+from django_spire.notification.models import Notification
+from django_spire.notification.sms.processor import SMSNotificationProcessor
+from django_spire.notification.sms.tests.factories import create_test_sms_notification
+
+
+class SMSNotificationProcessorTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.user = create_user(username='test_sms_processor_user')
+        self.processor = SMSNotificationProcessor()
+
+    @patch('django_spire.notification.sms.processor.Client')
+    @patch('django_spire.notification.sms.processor.TwilioSMSHelper')
+    def test_process_sets_status_to_sent(
+        self,
+        mock_helper_class: MagicMock,
+        mock_client_class: MagicMock
+    ):
+        mock_helper = MagicMock()
+        mock_helper_class.return_value = mock_helper
+
+        sms_notification = create_test_sms_notification(user=self.user)
+        notification = sms_notification.notification
+
+        self.processor.process(notification)
+
+        notification.refresh_from_db()
+        assert notification.status == NotificationStatusChoices.SENT
+
+    @patch('django_spire.notification.sms.processor.Client')
+    @patch('django_spire.notification.sms.processor.TwilioSMSHelper')
+    def test_process_sets_sent_datetime(
+        self,
+        mock_helper_class: MagicMock,
+        mock_client_class: MagicMock
+    ):
+        mock_helper = MagicMock()
+        mock_helper_class.return_value = mock_helper
+
+        sms_notification = create_test_sms_notification(user=self.user)
+        notification = sms_notification.notification
+
+        self.processor.process(notification)
+
+        notification.refresh_from_db()
+        assert notification.sent_datetime is not None
+
+    @patch('django_spire.notification.sms.processor.Client')
+    @patch('django_spire.notification.sms.processor.TwilioSMSHelper')
+    def test_process_calls_send(
+        self,
+        mock_helper_class: MagicMock,
+        mock_client_class: MagicMock
+    ):
+        mock_helper = MagicMock()
+        mock_helper_class.return_value = mock_helper
+
+        sms_notification = create_test_sms_notification(user=self.user)
+        notification = sms_notification.notification
+
+        self.processor.process(notification)
+
+        mock_helper.send.assert_called_once()
+
+    def test_process_raises_error_for_wrong_type(self):
+        notification = Notification.objects.create(
+            user=self.user,
+            type=NotificationTypeChoices.APP,
+            title='Test',
+            body='Test',
+            status=NotificationStatusChoices.PENDING,
+        )
+
+        with pytest.raises(NotificationError):
+            self.processor.process(notification)
+
+    @patch('django_spire.notification.sms.processor.Client')
+    @patch('django_spire.notification.sms.processor.BulkTwilioSMSHelper')
+    def test_process_list(
+        self,
+        mock_helper_class: MagicMock,
+        mock_client_class: MagicMock
+    ):
+        mock_helper = MagicMock()
+        mock_helper_class.return_value = mock_helper
+
+        notifications = [
+            create_test_sms_notification(user=self.user).notification
+            for _ in range(3)
+        ]
+
+        self.processor.process_list(notifications)
+
+        mock_helper.send_notifications.assert_called_once()

django_spire/notification/sms/tests/test_tools.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
+
+import pytest
+
 from django_spire.core.tests.test_cases import BaseTestCase
 from django_spire.notification.sms.tools import format_to_international_phone_number
 
 
 class TestSMSTools(BaseTestCase):
-
     def test_local_to_international_phone_number(self):
         phone_numbers = (
             '622 415 2736',
@@ -19,6 +22,7 @@ class TestSMSTools(BaseTestCase):
             '368.447-9514',
             '4563219876'
         )
+
         expected_phone_numbers = (
             '+16224152736',
             '+18815534599',
@@ -33,8 +37,12 @@ class TestSMSTools(BaseTestCase):
             '+13684479514',
             '+14563219876'
         )
-        formatted_phone_numbers = [format_to_international_phone_number(phone_number) for phone_number in phone_numbers]
-        self.assertSequenceEqual(formatted_phone_numbers, expected_phone_numbers)
+
+        formatted_phone_numbers = tuple(
+            format_to_international_phone_number(phone_number)
+            for phone_number in phone_numbers
+        )
+        assert formatted_phone_numbers == expected_phone_numbers
 
     def test_invalid_phone_number(self):
         phone_numbers = (
@@ -43,13 +51,19 @@ class TestSMSTools(BaseTestCase):
             '1',
             '12345678901234567890',
             '',
-            '32145698765', # excess 1 digit
-            '403000123', # missing 1 digit
-            '36800012', # missing 2 digits
+            '32145698765',
+            '403000123',
+            '36800012',
         )
+
         for phone_number in phone_numbers:
-            self.assertRaises(
-                ValueError,
-                format_to_international_phone_number,
-                phone_number
-            )
+            with pytest.raises(ValueError):
+                format_to_international_phone_number(phone_number)
+
+    def test_format_with_country_code(self):
+        result = format_to_international_phone_number('5551234567', country_code='1')
+        assert result == '+15551234567'
+
+    def test_format_already_has_country_code(self):
+        result = format_to_international_phone_number('15551234567', country_code='1')
+        assert result == '+15551234567'

django_spire/notification/sms/tools.py

@@ -1,7 +1,13 @@
+from __future__ import annotations
+
 import re
 
+from typing import TYPE_CHECKING
+
 from django_spire.notification.choices import NotificationStatusChoices
-from django_spire.notification.sms.models import SmsTemporaryMedia
+
+if TYPE_CHECKING:
+    from django_spire.notification.sms.models import SmsTemporaryMedia
 
 
 def update_unsent_notification_status_for_deleted_temporary_media(
@@ -19,21 +25,26 @@ def format_to_international_phone_number(phone_number: str, country_code: str='1
     Args: phone_number:
     Returns: international phone number format
     """
+
     if not phone_number:
-        raise ValueError(f'No phone number provided: {phone_number}')
+        message = f'No phone number provided: {phone_number}'
+        raise ValueError(message)
 
     # Remove extension numbers
     main_number = re.split(r'(?:ext\.?|x)\s*\d+', phone_number, flags=re.IGNORECASE)[0]
 
     # Get all digit characters
     digit_number = re.sub(r'\D', '', main_number)
+
     if digit_number.startswith(country_code) and len(digit_number) == 10 + len(country_code):
         digit_number = digit_number[len(country_code):]
 
     # Check if the number is in local format or already in international format
     if len(digit_number) == 10:
         return f'+{country_code}{digit_number}'
-    elif len(digit_number) == 10 + len(country_code) and digit_number.startswith(country_code):
+
+    if len(digit_number) == 10 + len(country_code) and digit_number.startswith(country_code):
         return f'+{digit_number}'
-    else:
-        raise ValueError(f'Invalid phone number: {phone_number}')
+
+    message = f'Invalid phone number: {phone_number}'
+    raise ValueError(message)

django_spire/notification/sms/urls/__init__.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 from django.urls import include, path
 
-app_name = 'sms'
 
+app_name = 'sms'
 
 urlpatterns = [
     path('media/', include('django_spire.notification.sms.urls.media_urls', namespace='media')),

django_spire/notification/sms/urls/media_urls.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from django_spire.notification.sms.views import media_views

django_spire/notification/sms/views/media_views.py

@@ -1,29 +1,39 @@
+from __future__ import annotations
+
 import base64
-import uuid
+
 from io import BytesIO
+from typing import TYPE_CHECKING
 
 from PIL import Image
 
 from django.http import HttpResponse
 from django.views.decorators.csrf import csrf_exempt
 
-from django_spire.notification.sms.exceptions import SmsTemporaryMediaException
+from django_spire.notification.sms.exceptions import SmsTemporaryMediaError
 from django_spire.notification.sms.models import SmsTemporaryMedia
 
+if TYPE_CHECKING:
+    import uuid
+
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 @csrf_exempt
-def external_temporary_media_view(request, external_access_key: uuid.UUID) -> HttpResponse:
+def external_temporary_media_view(request: WSGIRequest, external_access_key: uuid.UUID) -> HttpResponse:
     try:
         temporary_media = SmsTemporaryMedia.objects.get(external_access_key=external_access_key)
     except SmsTemporaryMedia.DoesNotExist:
         temporary_media = None
 
     if temporary_media is None or temporary_media.content == '':
-        raise SmsTemporaryMediaException("Content for Temporary Media cannot be empty")
+        message = 'Content for Temporary Media cannot be empty'
+        raise SmsTemporaryMediaError(message)
 
     image = Image.open(
         BytesIO(base64.b64decode(temporary_media.content))
     )
+
     image = image.convert('P', palette=Image.ADAPTIVE, colors=32)
 
     buffer = BytesIO()