feat: changed message object to dictionary when sending ACE_MESSAGE_SENT signal

edx_ace/__init__.py

@@ -13,7 +13,7 @@
 from .recipient import Recipient
 from .recipient_resolver import RecipientResolver
 
-__version__ = '1.11.1'
+__version__ = '1.11.2'
 
 
 __all__ = [

edx_ace/delivery.py

@@ -10,8 +10,8 @@
 from django.conf import settings
 
 from edx_ace.errors import RecoverableChannelDeliveryError
-from edx_ace.signals import ACE_MESSAGE_SENT
 from edx_ace.utils.date import get_current_time
+from edx_ace.utils.signals import send_ace_message_sent_signal
 
 LOG = logging.getLogger(__name__)
 
@@ -61,7 +61,7 @@ def deliver(channel, rendered_message, message):
             message.report(f'{channel_type}_delivery_retried', num_seconds)
         else:
             message.report(f'{channel_type}_delivery_succeeded', True)
-            ACE_MESSAGE_SENT.send(sender=channel, message=message)
+            send_ace_message_sent_signal(channel, message)
             return
 
     delivery_expired_report = f'{channel_type}_delivery_expired'

edx_ace/tests/test_delivery.py

@@ -34,19 +34,19 @@ def setUp(self):
         )
         self.current_time = datetime.datetime.utcnow().replace(tzinfo=tzutc())
 
-    @patch('edx_ace.delivery.ACE_MESSAGE_SENT.send')
+    @patch('edx_ace.delivery.send_ace_message_sent_signal')
     def test_happy_path(self, mock_ace_message_sent):
         deliver(self.mock_channel, sentinel.rendered_email, self.message)
         self.mock_channel.deliver.assert_called_once_with(self.message, sentinel.rendered_email)
         # check if ACE_MESSAGE_SENT is raised
-        mock_ace_message_sent.assert_called_once_with(sender=self.mock_channel, message=self.message)
+        mock_ace_message_sent.assert_called_once_with(self.mock_channel, self.message)
 
     def test_fatal_error(self):
         self.mock_channel.deliver.side_effect = FatalChannelDeliveryError('testing')
         with self.assertRaises(FatalChannelDeliveryError):
             deliver(self.mock_channel, sentinel.rendered_email, self.message)
 
-    @patch('edx_ace.delivery.ACE_MESSAGE_SENT.send')
+    @patch('edx_ace.delivery.send_ace_message_sent_signal')
     @patch('edx_ace.delivery.get_current_time')
     def test_custom_message_expiration(self, mock_get_current_time, mock_ace_message_sent):
         self.message.expiration_time = self.current_time - datetime.timedelta(seconds=10)
@@ -106,7 +106,7 @@ def test_multiple_retries(self, mock_get_current_time, mock_time):
         assert mock_time.sleep.call_args_list == [call(1), call(1)]
         assert self.mock_channel.deliver.call_count == 3
 
-    @patch('edx_ace.delivery.ACE_MESSAGE_SENT.send')
+    @patch('edx_ace.delivery.send_ace_message_sent_signal')
     def test_message_sent_signal_for_push_channel(self, mock_ace_message_sent):
         """
         Test that ACE_MESSAGE_SENT signal is sent when a message is delivered to a push channel.
@@ -117,4 +117,4 @@ def test_message_sent_signal_for_push_channel(self, mock_ace_message_sent):
         )
         deliver(mock_push_channel, sentinel.rendered_email, self.message)
         # check if ACE_MESSAGE_SENT is raised
-        mock_ace_message_sent.assert_called_once_with(sender=mock_push_channel, message=self.message)
+        mock_ace_message_sent.assert_called_once_with(mock_push_channel, self.message)

edx_ace/tests/utils/test_signals.py

@@ -0,0 +1,47 @@
+"""
+Tests for the utils/signals module.
+"""
+from django.test import TestCase
+
+from edx_ace.utils.signals import make_serializable_object
+
+
+class TestMakeSerializableObject(TestCase):
+    def test_primitive_types(self):
+        self.assertEqual(make_serializable_object(42), 42)
+        self.assertEqual(make_serializable_object(3.14), 3.14)
+        self.assertEqual(make_serializable_object("string"), "string")
+        self.assertEqual(make_serializable_object(True), True)
+        self.assertEqual(make_serializable_object(None), None)
+
+    def test_dict(self):
+        input_dict = {
+            "int": 1,
+            "float": 2.0,
+            "str": "test",
+            "bool": False,
+            "none": None,
+            "list": [1, 2, 3],
+            "nested_dict": {"key": "value"}
+        }
+        self.assertEqual(make_serializable_object(input_dict), input_dict)
+
+    def test_list(self):
+        input_list = [1, 2.0, "test", False, None, [1, 2, 3], {"key": "value"}]
+        self.assertEqual(make_serializable_object(input_list), input_list)
+
+    def test_non_serializable(self):
+        class NonSerializable:
+            pass
+
+        obj = NonSerializable()
+        self.assertEqual(make_serializable_object(obj), str(obj))
+
+    def test_non_serializable_list(self):
+        class NonSerializable:
+            pass
+
+        obj = NonSerializable()
+        obj2 = NonSerializable()
+        obj_list = [obj, obj2]
+        self.assertEqual(make_serializable_object(obj_list), [str(obj), str(obj2)])

edx_ace/utils/signals.py

@@ -0,0 +1,46 @@
+"""
+Utils for signals.
+"""
+from edx_ace.signals import ACE_MESSAGE_SENT
+
+
+def make_serializable_object(obj):
+    """
+    Takes a dictionary/list and returns a dictionary/list with all the values converted
+    to JSON serializable objects.
+    """
+    try:
+        if isinstance(obj, (int, float, str, bool)) or obj is None:
+            return obj
+        elif isinstance(obj, dict):
+            return {key: make_serializable_object(value) for key, value in obj.items()}
+        elif isinstance(obj, list):
+            return [make_serializable_object(element) for element in obj]
+    except Exception:    # pylint: disable=broad-except
+        pass
+    return str(obj)
+
+
+def send_ace_message_sent_signal(channel, message):
+    """
+    Creates dictionary from message, makes it JSON serializable and
+    sends the ACE_MESSAGE_SENT signal.
+    """
+    try:
+        channel_name = channel.__class__.__name__
+    except AttributeError:
+        channel_name = 'Other'
+    data = {
+        'name': message.name,
+        'app_label': message.app_label,
+        'recipient': {
+            'email': getattr(message.recipient, 'email_address', ''),
+            'user_id': getattr(message.recipient, 'lms_user_id', ''),
+        },
+        'channel': channel_name,
+        'context': message.context,
+        'options': message.options,
+        'uuid': str(message.uuid),
+        'send_uuid': str(message.send_uuid),
+    }
+    ACE_MESSAGE_SENT.send(sender=channel, message=make_serializable_object(data))