django-field-audit 1.2.9__tar.gz → 1.3.0__tar.gz

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-field-audit
-Version: 1.2.9
+Version: 1.3.0
 Summary: Audit Field Changes on Django Models
 Home-page: https://github.com/dimagi/django-field-audit
 Maintainer: Joel Miller
@@ -177,6 +177,44 @@ details:
   are only committed to the database if audit events are successfully created
   and saved as well.
 
+### Auditing Many-to-Many fields
+
+Many-to-Many field changes are automatically audited through Django signals when
+included in the `@audit_fields` decorator. Changes to M2M relationships generate
+audit events immediately without requiring `save()` calls.
+
+```python
+# Example model with audited M2M field
+@audit_fields("name", "title", "certifications")
+class CrewMember(models.Model):
+    name = models.CharField(max_length=256)
+    title = models.CharField(max_length=64)
+    certifications = models.ManyToManyField('Certification', blank=True)
+```
+
+#### Supported M2M operations
+
+All standard M2M operations create audit events:
+
+```python
+crew_member = CrewMember.objects.create(name='Test Pilot', title='Captain')
+cert1 = Certification.objects.create(name='PPL', certification_type='Private')
+
+crew_member.certifications.add(cert1)         # Creates audit event
+crew_member.certifications.remove(cert1)      # Creates audit event
+crew_member.certifications.set([cert1])       # Creates audit event
+crew_member.certifications.clear()            # Creates audit event
+```
+
+#### M2M audit event structure
+
+M2M changes use specific delta structures in audit events:
+
+- **Add**: `{'certifications': {'add': [1, 2]}}`
+- **Remove**: `{'certifications': {'remove': [2]}}`
+- **Clear**: `{'certifications': {'remove': [1, 2]}}`
+- **Create** / **Bootstrap**: `{'certifications': {'new': []}}`
+
 #### Bootstrap events for models with existing records
 
 In the scenario where auditing is enabled for a model with existing data, it can

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/README.md

@@ -140,6 +140,44 @@ details:
   are only committed to the database if audit events are successfully created
   and saved as well.
 
+### Auditing Many-to-Many fields
+
+Many-to-Many field changes are automatically audited through Django signals when
+included in the `@audit_fields` decorator. Changes to M2M relationships generate
+audit events immediately without requiring `save()` calls.
+
+```python
+# Example model with audited M2M field
+@audit_fields("name", "title", "certifications")
+class CrewMember(models.Model):
+    name = models.CharField(max_length=256)
+    title = models.CharField(max_length=64)
+    certifications = models.ManyToManyField('Certification', blank=True)
+```
+
+#### Supported M2M operations
+
+All standard M2M operations create audit events:
+
+```python
+crew_member = CrewMember.objects.create(name='Test Pilot', title='Captain')
+cert1 = Certification.objects.create(name='PPL', certification_type='Private')
+
+crew_member.certifications.add(cert1)         # Creates audit event
+crew_member.certifications.remove(cert1)      # Creates audit event
+crew_member.certifications.set([cert1])       # Creates audit event
+crew_member.certifications.clear()            # Creates audit event
+```
+
+#### M2M audit event structure
+
+M2M changes use specific delta structures in audit events:
+
+- **Add**: `{'certifications': {'add': [1, 2]}}`
+- **Remove**: `{'certifications': {'remove': [2]}}`
+- **Clear**: `{'certifications': {'remove': [1, 2]}}`
+- **Create** / **Bootstrap**: `{'certifications': {'new': []}}`
+
 #### Bootstrap events for models with existing records
 
 In the scenario where auditing is enabled for a model with existing data, it can

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/django_field_audit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-field-audit
-Version: 1.2.9
+Version: 1.3.0
 Summary: Audit Field Changes on Django Models
 Home-page: https://github.com/dimagi/django-field-audit
 Maintainer: Joel Miller
@@ -177,6 +177,44 @@ details:
   are only committed to the database if audit events are successfully created
   and saved as well.
 
+### Auditing Many-to-Many fields
+
+Many-to-Many field changes are automatically audited through Django signals when
+included in the `@audit_fields` decorator. Changes to M2M relationships generate
+audit events immediately without requiring `save()` calls.
+
+```python
+# Example model with audited M2M field
+@audit_fields("name", "title", "certifications")
+class CrewMember(models.Model):
+    name = models.CharField(max_length=256)
+    title = models.CharField(max_length=64)
+    certifications = models.ManyToManyField('Certification', blank=True)
+```
+
+#### Supported M2M operations
+
+All standard M2M operations create audit events:
+
+```python
+crew_member = CrewMember.objects.create(name='Test Pilot', title='Captain')
+cert1 = Certification.objects.create(name='PPL', certification_type='Private')
+
+crew_member.certifications.add(cert1)         # Creates audit event
+crew_member.certifications.remove(cert1)      # Creates audit event
+crew_member.certifications.set([cert1])       # Creates audit event
+crew_member.certifications.clear()            # Creates audit event
+```
+
+#### M2M audit event structure
+
+M2M changes use specific delta structures in audit events:
+
+- **Add**: `{'certifications': {'add': [1, 2]}}`
+- **Remove**: `{'certifications': {'remove': [2]}}`
+- **Clear**: `{'certifications': {'remove': [1, 2]}}`
+- **Create** / **Bootstrap**: `{'certifications': {'new': []}}`
+
 #### Bootstrap events for models with existing records
 
 In the scenario where auditing is enabled for a model with existing data, it can

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/django_field_audit.egg-info/SOURCES.txt

@@ -19,12 +19,14 @@ field_audit/management/commands/__init__.py
 field_audit/management/commands/bootstrap_field_audit_events.py
 field_audit/migrations/0001_initial.py
 field_audit/migrations/0002_add_is_bootstrap_column.py
+field_audit/migrations/0003_alter_auditevent_change_context_and_more.py
 field_audit/migrations/__init__.py
 tests/test_apps.py
 tests/test_auditors.py
 tests/test_bootstrap_field_audit_events.py
 tests/test_django_compat.py
 tests/test_field_audit.py
+tests/test_m2m.py
 tests/test_middleware.py
 tests/test_models.py
 tests/test_utils.py

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/field_audit/__init__.py

@@ -1,3 +1,3 @@
 from .field_audit import audit_fields  # noqa: F401
 
-__version__ = "1.2.9"
+__version__ = "1.3.0"

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/field_audit/field_audit.py

@@ -2,6 +2,7 @@ import contextvars
 from functools import wraps
 
 from django.db import models, router, transaction
+from django.db.models.signals import m2m_changed
 
 from .utils import get_fqcn
 
@@ -63,6 +64,8 @@ def audit_fields(*field_names, class_path=None, audit_special_queryset_writes=Fa
         cls.save = _decorate_db_write(cls.save)
         cls.delete = _decorate_db_write(cls.delete)
         cls.refresh_from_db = _decorate_refresh_from_db(cls.refresh_from_db)
+
+        _register_m2m_signals(cls, field_names)
         _audited_models[cls] = get_fqcn(cls) if class_path is None else class_path  # noqa: E501
         return cls
     if not field_names:
@@ -154,6 +157,86 @@ def _decorate_refresh_from_db(func):
     return wrapper
 
 
+def _register_m2m_signals(cls, field_names):
+    """Register m2m_changed signal handlers for ManyToManyFields.
+
+    :param cls: The model class being audited
+    :param field_names: List of field names that are being audited
+    """
+    for field_name in field_names:
+        try:
+            field = cls._meta.get_field(field_name)
+            if isinstance(field, models.ManyToManyField):
+                m2m_changed.connect(
+                    _m2m_changed_handler,
+                    sender=field.remote_field.through,
+                    weak=False
+                )
+        except Exception:
+            # If field doesn't exist or isn't a M2M field, continue
+            continue
+
+
+def _m2m_changed_handler(sender, instance, action, pk_set, **kwargs):
+    """Signal handler for m2m_changed to audit ManyToManyField changes.
+
+    :param sender: The intermediate model class for the ManyToManyField
+    :param instance: The instance whose many-to-many relation is updated
+    :param action: A string indicating the type of update
+    :param pk_set: For add/remove actions, set of primary key values
+    """
+    from .models import AuditEvent
+
+    if action not in ('post_add', 'post_remove', 'post_clear', 'pre_clear'):
+        return
+
+    if type(instance) not in _audited_models:
+        return
+
+    # Find which M2M field this change relates to
+    m2m_field = None
+    field_name = None
+    for field in instance._meta.get_fields():
+        if (
+            isinstance(field, models.ManyToManyField) and
+            hasattr(field, 'remote_field') and
+            field.remote_field.through == sender
+        ):
+            m2m_field = field
+            field_name = field.name
+            break
+
+    if not m2m_field or field_name not in AuditEvent.field_names(instance):
+        return
+
+    if action == 'pre_clear':
+        # `pk_set` not supplied for clear actions. Determine initial values
+        # in the `pre_clear` event
+        AuditEvent.attach_initial_m2m_values(instance, field_name)
+        return
+
+    if action == 'post_clear':
+        initial_values = AuditEvent.get_initial_m2m_values(instance, field_name)
+        if not initial_values:
+            return
+        delta = {field_name: {'remove': initial_values}}
+    else:
+        if not pk_set:
+            # the change was a no-op
+            return
+        delta_key = 'add' if action == 'post_add' else 'remove'
+        delta = {field_name: {delta_key: list(pk_set)}}
+
+    req = request.get()
+    event = AuditEvent.create_audit_event(
+        instance.pk, instance.__class__, delta, False, False, req
+    )
+    if event is not None:
+        event.save()
+
+    AuditEvent.clear_initial_m2m_field_values(instance, field_name)
+
+
 def get_audited_models():
     return _audited_models.copy()
 

django_field_audit-1.3.0/field_audit/migrations/0003_alter_auditevent_change_context_and_more.py

@@ -0,0 +1,32 @@
+# Generated by Django 5.1.6 on 2025-06-27 15:11
+
+import django.core.serializers.json
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('field_audit', '0002_add_is_bootstrap_column'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='auditevent',
+            name='change_context',
+            field=models.JSONField(
+                encoder=django.core.serializers.json.DjangoJSONEncoder),
+        ),
+        migrations.AlterField(
+            model_name='auditevent',
+            name='delta',
+            field=models.JSONField(
+                encoder=django.core.serializers.json.DjangoJSONEncoder),
+        ),
+        migrations.AlterField(
+            model_name='auditevent',
+            name='object_pk',
+            field=models.JSONField(
+                encoder=django.core.serializers.json.DjangoJSONEncoder),
+        ),
+    ]

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/field_audit/models.py

@@ -3,6 +3,7 @@ from functools import wraps
 from itertools import islice
 
 from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
 from django.db import models, transaction
 from django.db.models import Expression
 from django.utils import timezone
@@ -203,12 +204,12 @@ def get_date():
 class AuditEvent(models.Model):
     event_date = models.DateTimeField(default=get_date, db_index=True)
     object_class_path = models.CharField(db_index=True, max_length=255)
-    object_pk = models.JSONField()
-    change_context = models.JSONField()
+    object_pk = models.JSONField(encoder=DjangoJSONEncoder)
+    change_context = models.JSONField(encoder=DjangoJSONEncoder)
     is_create = models.BooleanField(default=False)
     is_delete = models.BooleanField(default=False)
     is_bootstrap = models.BooleanField(default=False)
-    delta = models.JSONField()
+    delta = models.JSONField(encoder=DjangoJSONEncoder)
 
     objects = get_manager("AUDITEVENT_MANAGER", DefaultAuditEventManager)
 
@@ -226,6 +227,7 @@ class AuditEvent(models.Model):
 
     ATTACH_FIELD_NAMES_AT = "__field_audit_field_names"
     ATTACH_INIT_VALUES_AT = "__field_audit_init_values"
+    ATTACH_INIT_M2M_VALUES_AT = "__field_audit_init_m2m_values"
 
     @classmethod
     def attach_field_names(cls, model_class, field_names):
@@ -245,13 +247,19 @@ class AuditEvent(models.Model):
         return getattr(model_class, cls.ATTACH_FIELD_NAMES_AT)
 
     @staticmethod
-    def get_field_value(instance, field_name):
+    def get_field_value(instance, field_name, bootstrap=False):
         """Returns the database value of a field on ``instance``.
 
         :param instance: an instance of a Django model
         :param field_name: name of a field on ``instance``
         """
         field = instance._meta.get_field(field_name)
+
+        if isinstance(field, models.ManyToManyField):
+            # ManyToManyField handled by Django signals
+            if bootstrap:
+                return AuditEvent.get_m2m_field_value(instance, field_name)
+            return []
         return field.to_python(field.value_from_object(instance))
 
     @classmethod
@@ -275,6 +283,44 @@ class AuditEvent(models.Model):
         init_values = {f: cls.get_field_value(instance, f) for f in field_names}
         setattr(instance, cls.ATTACH_INIT_VALUES_AT, init_values)
 
+    @classmethod
+    def attach_initial_m2m_values(cls, instance, field_name):
+        field = instance._meta.get_field(field_name)
+        if not isinstance(field, models.ManyToManyField):
+            return None
+
+        values = cls.get_m2m_field_value(instance, field_name)
+        init_values = getattr(
+            instance, cls.ATTACH_INIT_M2M_VALUES_AT, None
+        ) or {}
+        init_values.update({field_name: values})
+        setattr(instance, cls.ATTACH_INIT_M2M_VALUES_AT, init_values)
+
+    @classmethod
+    def get_initial_m2m_values(cls, instance, field_name):
+        init_values = getattr(
+            instance, cls.ATTACH_INIT_M2M_VALUES_AT, None
+        ) or {}
+        return init_values.get(field_name)
+
+    @classmethod
+    def clear_initial_m2m_field_values(cls, instance, field_name):
+        init_values = getattr(
+            instance, cls.ATTACH_INIT_M2M_VALUES_AT, None
+        ) or {}
+        init_values.pop(field_name, None)
+        setattr(instance, cls.ATTACH_INIT_M2M_VALUES_AT, init_values)
+
+    @classmethod
+    def get_m2m_field_value(cls, instance, field_name):
+        if instance.pk is None:
+            # Instance is not saved, return empty list
+            return []
+        else:
+            # Instance is saved, we can access the related objects
+            related_manager = getattr(instance, field_name)
+            return list(related_manager.values_list('pk', flat=True))
+
     @classmethod
     def reset_initial_values(cls, instance):
         """Returns the previously attached "initial values" and attaches new
@@ -396,7 +442,6 @@ class AuditEvent(models.Model):
             object_pk = instance.pk
 
         delta = cls.get_delta_from_instance(instance, is_create, is_delete)
-
         if delta:
             return cls.create_audit_event(object_pk, type(instance), delta,
                                           is_create, is_delete, request)
@@ -471,7 +516,9 @@ class AuditEvent(models.Model):
             for instance in iter_records():
                 delta = {}
                 for field_name in field_names:
-                    value = cls.get_field_value(instance, field_name)
+                    value = cls.get_field_value(
+                        instance, field_name, bootstrap=True
+                    )
                     delta[field_name] = {"new": value}
                 yield cls(
                     object_class_path=object_class_path,

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/tests/test_field_audit.py

@@ -21,6 +21,7 @@ from field_audit.models import AuditEvent, AuditingManager
 from .models import (
     Aerodrome,
     Aircraft,
+    Certification,
     CrewMember,
     Flight,
     SimpleModel,
@@ -123,6 +124,7 @@ class TestFieldAudit(TestCase):
                 Aerodrome,
                 Aircraft,
                 CrewMember,
+                Certification,
                 Flight,
                 SimpleModel,
                 ModelWithAuditingManager,

django_field_audit-1.3.0/tests/test_m2m.py

@@ -0,0 +1,229 @@
+from unittest.mock import ANY, patch
+
+from django.test import TestCase
+
+from field_audit.const import BOOTSTRAP_BATCH_SIZE
+from field_audit.models import AuditEvent
+
+
+class TestAuditEventM2M(TestCase):
+    def test_manytomany_field_auditing(self):
+        """Test ManyToManyField relationships are properly handled."""
+        from .models import CrewMember, Certification
+
+        # Create some certifications
+        cert1 = Certification.objects.create(
+            name='Private Pilot License',
+            certification_type='PPL'
+        )
+        cert2 = Certification.objects.create(
+            name='Instrument Rating',
+            certification_type='IR'
+        )
+
+        # Create a crew member
+        crew_member = CrewMember.objects.create(
+            name='Test Pilot',
+            title='Captain',
+            flight_hours=1500.0
+        )
+
+        # Add certifications to crew member
+        crew_member.certifications.set([cert1, cert2])
+
+        events = AuditEvent.objects.by_model(CrewMember).order_by('event_date')
+        self.assertEqual(events.count(), 2)
+
+        # Check the create event
+        create_event = events.filter(is_create=True).first()
+        self.assertIsNotNone(create_event)
+
+        # Delta should contain field values including ManyToMany field
+        delta = create_event.delta
+        self.assertIn('name', delta)
+        self.assertIn('title', delta)
+        self.assertIn('flight_hours', delta)
+        self.assertEqual(delta['certifications']['new'], [])
+
+        update_event = events.filter(is_create=False).first()
+        self.assertIsNotNone(update_event)
+        delta = update_event.delta
+        self.assertEqual(
+            set(delta['certifications']['add']), {cert1.id, cert2.id}
+        )
+
+    def test_manytomany_field_modification_auditing(self):
+        """Test that ManyToManyField changes are properly audited."""
+        from .models import CrewMember, Certification
+
+        cert1 = Certification.objects.create(
+            name='PPL', certification_type='Private'
+        )
+        cert2 = Certification.objects.create(
+            name='IR', certification_type='Instrument'
+        )
+        cert3 = Certification.objects.create(
+            name='CPL', certification_type='Commercial'
+        )
+
+        crew_member = CrewMember.objects.create(
+            name='Test Pilot',
+            title='Captain',
+            flight_hours=1500.0
+        )
+        crew_member.certifications.set([cert1, cert2])
+
+        # Modify certifications (remove cert2, add cert3)
+        crew_member.certifications.set([cert1, cert3])
+
+        events = AuditEvent.objects.by_model(CrewMember).order_by('event_date')
+        latest_events = events.filter(is_create=False, is_delete=False)
+        self.assertEqual(latest_events.count(), 3)
+        certification_deltas = [
+            event.delta['certifications'] for event in latest_events
+        ]
+        self.assertEqual(
+            [list(delta) for delta in certification_deltas],
+            [['add'], ['remove'], ['add']]
+        )
+        self.assertEqual(
+            [set(list(delta.values())[0]) for delta in certification_deltas],
+            [{cert1.id, cert2.id}, {cert2.id}, {cert3.id}]
+        )
+
+    def test_manytomany_field_clear_auditing(self):
+        """Test that clearing ManyToManyField is properly audited."""
+        from .models import CrewMember, Certification
+
+        # Create certifications and crew member
+        cert1 = Certification.objects.create(
+            name='PPL', certification_type='Private'
+        )
+        cert2 = Certification.objects.create(
+            name='IR', certification_type='Instrument'
+        )
+
+        crew_member = CrewMember.objects.create(
+            name='Test Pilot',
+            title='Captain',
+            flight_hours=1500.0
+        )
+        crew_member.certifications.set([cert1, cert2])
+
+        initial_events_count = AuditEvent.objects.by_model(
+            CrewMember
+        ).count()
+
+        # Clear all certifications
+        crew_member.certifications.clear()
+
+        events = AuditEvent.objects.by_model(CrewMember).order_by('event_date')
+        self.assertEqual(events.count(), initial_events_count + 1)
+
+        latest_event = events.filter(
+            is_create=False, is_delete=False
+        ).last()
+        delta = latest_event.delta
+        self.assertEqual(
+            set(delta['certifications']['remove']), {cert1.id, cert2.id}
+        )
+
+    def test_manytomany_field_realtime_auditing_with_add_remove(self):
+        """Test M2M changes create audit events immediately via signals."""
+        from .models import CrewMember, Certification
+
+        # Create certifications and crew member
+        cert1 = Certification.objects.create(
+            name='PPL', certification_type='Private'
+        )
+        cert2 = Certification.objects.create(
+            name='IR', certification_type='Instrument'
+        )
+
+        crew_member = CrewMember.objects.create(
+            name='Test Pilot',
+            title='Captain',
+            flight_hours=1500.0
+        )
+
+        initial_events_count = AuditEvent.objects.by_model(
+            CrewMember
+        ).count()
+        self.assertEqual(initial_events_count, 1)
+
+        # Test direct add() - should create audit event immediately
+        crew_member.certifications.add(cert1, cert2)
+
+        # Check audit event was created immediately (without save())
+        events = AuditEvent.objects.by_model(CrewMember).order_by(
+            'event_date'
+        )
+
+        new_events = list(events[initial_events_count:])
+        self.assertEqual(
+            len(new_events), 1, "M2M add() should create audit event"
+        )
+        latest_event = new_events[-1]
+        self.assertIn('certifications', latest_event.delta)
+        self.assertEqual(
+            set(latest_event.delta['certifications']['add']),
+            {cert1.id, cert2.id}
+        )
+
+        # Test direct remove() - should create audit event immediately
+        current_events_count = events.count()
+        crew_member.certifications.remove(cert1)
+
+        events = AuditEvent.objects.by_model(CrewMember).order_by(
+            'event_date'
+        )
+        self.assertEqual(
+            events.count(), current_events_count + 1,
+            "M2M remove() should create audit event"
+        )
+
+        # Check the remove event
+        latest_event = events.last()
+        self.assertIn('certifications', latest_event.delta)
+        self.assertEqual(
+            set(latest_event.delta['certifications']['remove']), {cert1.id}
+        )
+
+
+class TestAuditEventBootstrappingM2M(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        from tests.models import Certification, CrewMember
+        cls.cert1 = Certification.objects.create(
+            name='PPL', certification_type='Private'
+        )
+        cls.cert2 = Certification.objects.create(
+            name='IR', certification_type='Instrument'
+        )
+
+        crew_member = CrewMember.objects.create(
+            name='Test Pilot',
+            title='Captain',
+            flight_hours=1500.0
+        )
+        crew_member.certifications.set([cls.cert1, cls.cert2])
+
+    def test_bootstrap_existing_model_records_m2m(self):
+        from tests.models import CrewMember
+        self.assertEqual([], list(AuditEvent.objects.filter(is_bootstrap=True)))
+        with patch.object(AuditEvent.objects, "bulk_create",
+                          side_effect=AuditEvent.objects.bulk_create) as mock:
+            created_count = AuditEvent.bootstrap_existing_model_records(
+                CrewMember,
+                ['certifications'],
+            )
+            mock.assert_called_once_with(ANY, batch_size=BOOTSTRAP_BATCH_SIZE)
+        bootstrap_events = AuditEvent.objects.filter(is_bootstrap=True)
+        self.assertEqual(len(bootstrap_events), created_count)
+        event = bootstrap_events[0]
+        self.assertEqual(
+            set(event.delta['certifications']['new']),
+            {self.cert1.id, self.cert2.id}
+        )

{django_field_audit-1.2.9 → django_field_audit-1.3.0}/tests/test_models.py

@@ -398,6 +398,33 @@ class TestAuditEvent(TestCase):
         capt = CrewMember(title=CleverTitle("Captain"))
         self.assertEqual("Captain", AuditEvent.get_field_value(capt, "title"))
 
+    def test_decimal_field_serialization(self):
+        """Test that DecimalField values are properly handled in audit events.
+        """
+        from decimal import Decimal
+
+        # Create a CrewMember with a decimal field
+        CrewMember.objects.create(
+            name='Test Pilot',
+            title='Captain',
+            flight_hours=Decimal('1234.5678')
+        )
+
+        # Check that the audit event was created successfully
+        events = AuditEvent.objects.filter(
+            object_class_path='tests.models.CrewMember')
+        self.assertEqual(events.count(), 1)
+
+        event = events.first()
+
+        # The decimal value should be serialized as a string in the delta
+        flight_hours_new = event.delta["flight_hours"]["new"]
+        self.assertIsInstance(flight_hours_new, str)
+        self.assertEqual(flight_hours_new, '1234.5678')
+
+        # Verify the string can be converted back to Decimal
+        self.assertEqual(Decimal(flight_hours_new), Decimal('1234.5678'))
+
     def test_event_date_default(self):
         event = AuditEvent.objects.create(**EVENT_REQ_FIELDS)
         self.assertLess(