wbmailing 2.2.1__py2.py3-none-any.whl

wbmailing/tests/models/test_mailing_lists.py

@@ -0,0 +1,297 @@
+import pytest
+from django.contrib.auth.models import Permission
+from faker import Faker
+from wbcore.contrib.authentication.factories import UserFactory
+from wbmailing.models.mailing_lists import (
+    MailingList,
+    MailingListEmailContactThroughModel,
+    MailingListSubscriberChangeRequest,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestMailingListSubscriberChangeRequest:
+    @pytest.fixture
+    def user_admin(self):
+        user = UserFactory.create()
+        perm = Permission.objects.get(codename="administrate_mailinglistsubscriberchangerequest")
+        user.user_permissions.add(perm)
+        return user
+
+    def test_init(self, mailing_list_subscriber_change_request):
+        """
+        Test basics creation logic:
+        - relationship creation from email contact and mailing list
+        """
+        assert mailing_list_subscriber_change_request
+        assert mailing_list_subscriber_change_request.status == MailingListSubscriberChangeRequest.Status.PENDING
+        rel = mailing_list_subscriber_change_request.relationship
+        assert rel.email_contact == mailing_list_subscriber_change_request.email_contact
+        assert rel.mailing_list == mailing_list_subscriber_change_request.mailing_list
+        assert rel.status == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+
+    @pytest.mark.parametrize("mailing_list__is_public", [True, False])
+    def test_init_public_mailing_list(self, mailing_list_subscriber_change_request_factory, mailing_list):
+        """
+        Test if a request subscription creation to a public mailing list is automatically approved
+        """
+        request = mailing_list_subscriber_change_request_factory.create(mailing_list=mailing_list)
+        assert request.type == MailingListSubscriberChangeRequest.Type.SUBSCRIBING
+        if mailing_list.is_public:
+            assert request.status == MailingListSubscriberChangeRequest.Status.APPROVED
+        else:
+            assert request.status == MailingListSubscriberChangeRequest.Status.PENDING
+
+    @pytest.mark.parametrize(
+        "mailing_list_subscriber_change_request__type, description",
+        [
+            (MailingListSubscriberChangeRequest.Type.SUBSCRIBING, fake.sentence()),
+            (MailingListSubscriberChangeRequest.Type.UNSUBSCRIBING, fake.sentence()),
+        ],
+    )
+    def test_approve(self, mailing_list_subscriber_change_request, user, description):
+        mailing_list_subscriber_change_request.approve(by=user, description=description)
+        if mailing_list_subscriber_change_request.type == MailingListSubscriberChangeRequest.Type.SUBSCRIBING:
+            assert (
+                mailing_list_subscriber_change_request.relationship.status
+                == MailingListEmailContactThroughModel.Status.SUBSCRIBED
+            )
+        else:
+            assert (
+                mailing_list_subscriber_change_request.relationship.status
+                == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+            )
+        assert mailing_list_subscriber_change_request.approver == user.profile
+        assert mailing_list_subscriber_change_request.reason == description
+
+    @pytest.mark.parametrize("description", [fake.sentence()])
+    def test_deny(self, mailing_list_subscriber_change_request, user, description):
+        """
+        Coverage test and unit test on description and approver from action trigerer
+        """
+        mailing_list_subscriber_change_request.deny(by=user, description=description)
+        mailing_list_subscriber_change_request.save()
+        assert mailing_list_subscriber_change_request.approver == user.profile
+        assert mailing_list_subscriber_change_request.reason == description
+
+    @pytest.mark.parametrize(
+        "mailing_list_email_contact_through_model__status, type, res",
+        [
+            (
+                MailingListEmailContactThroughModel.Status.SUBSCRIBED,
+                MailingListSubscriberChangeRequest.Type.UNSUBSCRIBING,
+                False,
+            ),
+            (
+                MailingListEmailContactThroughModel.Status.SUBSCRIBED,
+                MailingListSubscriberChangeRequest.Type.SUBSCRIBING,
+                False,
+            ),
+            (
+                MailingListEmailContactThroughModel.Status.UNSUBSCRIBED,
+                MailingListSubscriberChangeRequest.Type.UNSUBSCRIBING,
+                False,
+            ),
+            (
+                MailingListEmailContactThroughModel.Status.UNSUBSCRIBED,
+                MailingListSubscriberChangeRequest.Type.SUBSCRIBING,
+                True,
+            ),
+        ],
+    )
+    def test_subscribing(
+        self, mailing_list_email_contact_through_model, mailing_list_subscriber_change_request_factory, type, res
+    ):
+        """
+        Basic property result check
+        """
+        request = mailing_list_subscriber_change_request_factory.create(
+            type=type,
+            relationship=mailing_list_email_contact_through_model,
+            email_contact=mailing_list_email_contact_through_model.email_contact,
+            mailing_list=mailing_list_email_contact_through_model.mailing_list,
+        )
+        assert request.subscribing == res
+
+    def test_get_expired_date_subquery(
+        self, email_contact, mailing_list, mailing_list_subscriber_change_request_factory
+    ):
+        """
+        Check that expired date is the last approved and subscribing mailing change request
+        """
+        mailing_list_subscriber_change_request_factory.create(
+            type=MailingListSubscriberChangeRequest.Type.SUBSCRIBING,
+            status=MailingListSubscriberChangeRequest.Status.APPROVED,
+            mailing_list=mailing_list,
+            email_contact=email_contact,
+            expiration_date=fake.date_object(),
+        )  # oldest valid request
+        req = mailing_list_subscriber_change_request_factory.create(
+            type=MailingListSubscriberChangeRequest.Type.SUBSCRIBING,
+            status=MailingListSubscriberChangeRequest.Status.APPROVED,
+            mailing_list=mailing_list,
+            email_contact=email_contact,
+            expiration_date=fake.date_object(),
+        )  # expected expiration time request
+        mailing_list_subscriber_change_request_factory.create(
+            type=MailingListSubscriberChangeRequest.Type.UNSUBSCRIBING,
+            status=MailingListSubscriberChangeRequest.Status.APPROVED,
+            mailing_list=mailing_list,
+            email_contact=email_contact,
+            expiration_date=fake.date_object(),
+        )  # Unvalid request because not subscribing
+        mailing_list_subscriber_change_request_factory.create(
+            type=MailingListSubscriberChangeRequest.Type.SUBSCRIBING,
+            status=MailingListSubscriberChangeRequest.Status.PENDING,
+            mailing_list=mailing_list,
+            email_contact=email_contact,
+            expiration_date=fake.date_object(),
+        )  # Unvalid request because pending
+        assert (
+            MailingListEmailContactThroughModel.objects.annotate(
+                expiration_date=MailingListEmailContactThroughModel.get_expired_date_subquery()
+            )
+            .filter(mailing_list=mailing_list, email_contact=email_contact)
+            .values_list("expiration_date", flat=True)[0]
+            == req.expiration_date
+        )
+
+    def test_get_approvers(self, user, user_admin):
+        """
+        Test that approvers are the proper user with admin rights
+        """
+        assert set(MailingListSubscriberChangeRequest.get_approvers()) == {user_admin}
+        assert not MailingListSubscriberChangeRequest.get_approvers().filter(id=user.id).exists()
+
+
+@pytest.mark.django_db
+class TestMailingListEmailContactThroughModel:
+    def test_init(self, mailing_list_email_contact_through_model):
+        assert mailing_list_email_contact_through_model
+
+    def test_change_state(self, mailing_list_email_contact_through_model):
+        initial_status = mailing_list_email_contact_through_model.status
+        mailing_list_email_contact_through_model.change_state()
+        assert mailing_list_email_contact_through_model.status == initial_status
+        assert (
+            mailing_list_email_contact_through_model.requests.filter(
+                status=MailingListSubscriberChangeRequest.Status.PENDING
+            ).count()
+            == 1
+        )
+        mailing_list_email_contact_through_model.change_state(automatically_approve=True)
+        mailing_list_email_contact_through_model.refresh_from_db()
+        assert not mailing_list_email_contact_through_model.requests.filter(
+            status=MailingListSubscriberChangeRequest.Status.PENDING
+        ).exists()
+        assert mailing_list_email_contact_through_model.status != initial_status
+
+
+@pytest.mark.django_db
+class TestMailingList:
+    def test_init(self, mailing_list):
+        assert mailing_list
+
+    @pytest.mark.parametrize(
+        "mailing_list_email_contact_through_model__status", [MailingListEmailContactThroughModel.Status.SUBSCRIBED]
+    )
+    def test_unsubscription(self, mailing_list_email_contact_through_model):
+        """
+        Test unsubscription
+        """
+        email_contact = mailing_list_email_contact_through_model.email_contact
+        mailing_list = mailing_list_email_contact_through_model.mailing_list
+
+        mailing_list.unsubscribe(email_contact)
+        req = mailing_list_email_contact_through_model.requests.get(
+            status=MailingListSubscriberChangeRequest.Status.PENDING
+        )
+        assert (
+            mailing_list_email_contact_through_model.status == MailingListEmailContactThroughModel.Status.SUBSCRIBED
+        )  # We expect the contact to still be subscribed because the unsubscription request is still pending
+        req.approve()
+        mailing_list_email_contact_through_model.refresh_from_db()
+        assert (
+            mailing_list_email_contact_through_model.status == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+        )
+
+    @pytest.mark.parametrize(
+        "mailing_list_email_contact_through_model__status", [MailingListEmailContactThroughModel.Status.SUBSCRIBED]
+    )
+    def test_unsubscription_automatically_approve(self, mailing_list_email_contact_through_model):
+        """
+        Test automatically approved unsubscription change request
+        """
+        email_contact = mailing_list_email_contact_through_model.email_contact
+        mailing_list = mailing_list_email_contact_through_model.mailing_list
+
+        mailing_list.unsubscribe(email_contact, automatically_approve=True)
+        mailing_list_email_contact_through_model.refresh_from_db()
+        assert (
+            mailing_list_email_contact_through_model.status == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+        )
+
+    @pytest.mark.parametrize(
+        "mailing_list_email_contact_through_model__status", [MailingListEmailContactThroughModel.Status.UNSUBSCRIBED]
+    )
+    def test_subscription(self, mailing_list_email_contact_through_model):
+        """
+        Test subscription change request
+        """
+        email_contact = mailing_list_email_contact_through_model.email_contact
+        mailing_list = mailing_list_email_contact_through_model.mailing_list
+
+        mailing_list.subscribe(email_contact)
+        req = mailing_list_email_contact_through_model.requests.get(
+            status=MailingListSubscriberChangeRequest.Status.PENDING
+        )
+        assert (
+            mailing_list_email_contact_through_model.status == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+        )  # We expect the contact to still be subscribed because the unsubscription request is still pending
+        req.approve()
+        mailing_list_email_contact_through_model.refresh_from_db()
+        assert mailing_list_email_contact_through_model.status == MailingListEmailContactThroughModel.Status.SUBSCRIBED
+
+    @pytest.mark.parametrize(
+        "mailing_list_email_contact_through_model__status", [MailingListEmailContactThroughModel.Status.UNSUBSCRIBED]
+    )
+    def test_subscription_automatically_approve(self, mailing_list_email_contact_through_model):
+        """
+        Test automatically approved subscription change request
+        """
+        email_contact = mailing_list_email_contact_through_model.email_contact
+        mailing_list = mailing_list_email_contact_through_model.mailing_list
+
+        mailing_list.subscribe(email_contact, automatically_approve=True)
+        mailing_list_email_contact_through_model.refresh_from_db()
+        assert mailing_list_email_contact_through_model.status == MailingListEmailContactThroughModel.Status.SUBSCRIBED
+
+    def test_get_subscribed_mailing_lists(self, mailing_list_email_contact_through_model_factory):
+        """
+        Test subscribed mailing list for a email contact.
+        """
+        rel_e1_ml1_subscribed = mailing_list_email_contact_through_model_factory.create(
+            status=MailingListEmailContactThroughModel.Status.SUBSCRIBED
+        )
+        e1 = rel_e1_ml1_subscribed.email_contact
+        m1 = rel_e1_ml1_subscribed.mailing_list
+
+        rel_e1_rel_ml2_unsubscribed = mailing_list_email_contact_through_model_factory.create(
+            email_contact=e1, status=MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+        )  # We expect e1 to not show up in the valid emails queryset
+        m2 = rel_e1_rel_ml2_unsubscribed.mailing_list
+
+        rel_e2_ml1_subscribed = mailing_list_email_contact_through_model_factory.create(
+            mailing_list=m1, status=MailingListEmailContactThroughModel.Status.SUBSCRIBED
+        )
+        e2 = rel_e2_ml1_subscribed.email_contact
+        mailing_list_email_contact_through_model_factory.create(
+            email_contact=e2, mailing_list=m2, status=MailingListEmailContactThroughModel.Status.SUBSCRIBED
+        )
+
+        assert set(MailingList.get_subscribed_mailing_lists(e1)) == {
+            m1,
+        }
+        assert set(MailingList.get_subscribed_mailing_lists(e2)) == {m1, m2}

wbmailing/tests/models/test_mails.py

@@ -0,0 +1,205 @@
+from unittest.mock import patch
+
+import pytest
+from anymail.signals import AnymailTrackingEvent, tracking
+from django.core import mail
+from django.test import override_settings
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.directory.factories import EmailContactFactory
+from wbcore.contrib.documents.factories import DocumentFactory
+from wbcore.test.utils import get_or_create_superuser
+from wbmailing.backend import SendgridEmailBackend
+from wbmailing.factories import ToEmailMailFactory
+from wbmailing.models import MailEvent, MassMail
+from wbmailing.models.mails import (
+    can_administrate_mail,
+    send_mail_task,
+    send_mass_mail_as_task,
+)
+
+
+@pytest.mark.django_db
+class TestSpecificModels:
+    @patch("wbmailing.models.mails.send_mass_mail_as_task.delay")
+    def test_send_mail_task(self, send_mass_mail_as_task, mass_mail_factory, mailing_list_factory):
+        ec = EmailContactFactory()
+        ml = mailing_list_factory(email_contacts=(ec,))
+        mm = mass_mail_factory(mailing_lists=(ml,))
+
+        send_mail_task(mm.id)
+        send_mass_mail_as_task.assert_called()
+        assert send_mass_mail_as_task.call_count == 1
+
+    def test_send_mass_mail_as_task(self, mass_mail_factory, mailing_list_factory):
+        ec = EmailContactFactory()
+        ml = mailing_list_factory(email_contacts=(ec,))
+        mass_mail = mass_mail_factory(mailing_lists=(ml,))
+        assert len(mail.outbox) == 0
+        for subscriber in mass_mail.get_mail_addresses():
+            send_mass_mail_as_task(mass_mail.id, subscriber["address"])
+        assert len(mail.outbox) == 1
+
+    @pytest.mark.parametrize("status, expected", [("PENDING", "DENIED")])
+    def test_deny(self, mailing_list_subscriber_change_request_factory, status, expected):
+        mlscr = mailing_list_subscriber_change_request_factory()
+        mlscr.deny(description="SPAM")
+        assert mlscr.status == expected
+
+    @pytest.mark.parametrize("status, expected", [("DRAFT", "PENDING")])
+    def test_submit(self, mass_mail_factory, status, expected):
+        ml = mass_mail_factory()
+        ml.submit()
+        assert ml.status == expected
+
+    @pytest.mark.parametrize("status, expected", [("PENDING", "DENIED")])
+    def test_deny2(self, mass_mail_factory, status, expected):
+        ml = mass_mail_factory(status=MassMail.Status.PENDING)
+        ml.deny()
+        assert ml.status == expected
+
+    @pytest.mark.parametrize("status, expected", [("PENDING", "DRAFT")])
+    def test_revise(self, mass_mail_factory, status, expected):
+        ml = mass_mail_factory(status=MassMail.Status.PENDING)
+        ml.revise()
+        assert ml.status == expected
+
+    @patch("wbmailing.models.mails.send_mail_task.delay")
+    def test_send(self, send_mail_task, mass_mail_factory):
+        mm = mass_mail_factory(status=MassMail.Status.PENDING)
+        mm.send()
+        send_mail_task.assert_called()
+        assert send_mail_task.call_count == 1
+
+    def test_create_email(self, mass_mail_factory):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        mm = mass_mail_factory(attachments=(DocumentFactory(),))
+        EmailContactFactory(address=request.user.email)
+        mm.template = None
+        mm.save()
+        msg = mm.create_email(request.user.email)
+        assert msg
+
+    @patch("wbmailing.models.mails.send_mail_as_task.delay")
+    def test_resend_no_massmail(self, send_mail_as_task):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        obj = ToEmailMailFactory(attachments=(DocumentFactory(),))
+        obj.mass_mail = None
+        obj.save()
+        obj.resend()
+        send_mail_as_task.assert_called()
+        assert send_mail_as_task.call_count == 1
+
+    @patch("wbmailing.models.mails.send_mail_as_task.delay")
+    def test_resend_no_template(self, send_mail_as_task):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        obj = ToEmailMailFactory()
+        obj.mass_mail.template = None
+        obj.mass_mail.save()
+        obj.resend()
+        send_mail_as_task.assert_called()
+        assert send_mail_as_task.call_count == 1
+
+    @override_settings(EMAIL_BACKEND="anymail.backends.test.EmailBackend")
+    @pytest.mark.parametrize(
+        "exits_message_id, event_type, reject_reason",
+        [
+            ("YES", MailEvent.EventType.SENT, None),
+            ("YES", MailEvent.EventType.SENT, MailEvent.RejectReason.SPAM),
+            ("YES", "Other", "Unknow"),
+            ("NO", "Other", None),
+        ],
+    )
+    def test_handle_mail_tracking(self, exits_message_id, event_type, reject_reason, mail_factory, mail_event_factory):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        ml = ToEmailMailFactory()
+        nb_mail_send = len(mail.outbox)
+        esp_event = {}
+        if reject_reason:
+            mailevent = mail_event_factory(mail=ml, description="", reject_reason=reject_reason)
+            if reject_reason == MailEvent.RejectReason.SPAM:
+                esp_event["reason"] = "SPAM"
+            else:
+                esp_event["response"] = "Unknow"
+        else:
+            mailevent = mail_event_factory(mail=ml)
+
+        to = list(ml.to_email.values_list("address", flat=True))
+        msg = ml.get_mailmessage(ml.subject, ml.body, request.user.email, to, attachments=ml.documents.all())
+        msg.send()
+        assert len(mail.outbox) == nb_mail_send + 1
+        assert msg.anymail_status.status == {"sent"}
+        if exits_message_id == "YES":
+            message_id = mailevent.mail.message_ids[0]
+        else:
+            message_id = msg.anymail_status.message_id
+
+        esp_event["ip"] = mailevent.ip
+        esp_event["useragent"] = mailevent.user_agent
+        mevent = AnymailTrackingEvent(
+            event_type=event_type,
+            message_id=message_id,
+            timestamp=mailevent.timestamp,
+            event_id=mailevent.id,
+            recipient=mailevent.recipient,
+            reject_reason=mailevent.reject_reason,
+            description=mailevent.description,
+            user_agent=mailevent.user_agent,
+            click_url=mailevent.click_url,
+            esp_event=esp_event,
+        )
+        # sender(class) – The source of the event.  (One of theanymail.webhook.*Viewclasses, but you generally won’t examine this parameter; it’s required by Django’s signalmechanism.
+        tracking.send(sender=msg, event=mevent, esp_name="SendGrid")
+
+        if exits_message_id == "YES":
+            assert MailEvent.objects.filter(mail=ml, recipient=mailevent.recipient).count() == 2
+        else:
+            assert MailEvent.objects.filter(mail=ml, recipient=mailevent.recipient).count() == 1
+
+    @override_settings(EMAIL_BACKEND="anymail.backends.test.EmailBackend", ANYMAIL_SENDGRID_API_KEY="TEST")
+    @patch("wbmailing.backend.SendgridEmailBackend._send")
+    @pytest.mark.parametrize("resend, exit_document", [(False, False), (False, True), (True, False)])
+    def test_SendgridEmailBackend_send_messages(self, mock_send, resend, exit_document):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        num_sent = SendgridEmailBackend().send_messages(None)
+        assert num_sent == 0
+        doc1 = DocumentFactory()
+        ml = ToEmailMailFactory(cc_email=(EmailContactFactory(),), attachments=(doc1,))
+        to = list(ml.to_email.values_list("address", flat=True))
+        cc = list(ml.cc_email.values_list("address", flat=True))
+        bcc = ["lemissan@atonra.ch"]
+        if resend:
+            msg = ml.get_mailmessage(
+                ml.subject, ml.body, request.user.email, to, attachments=ml.documents.all(), mail=ml
+            )
+        else:
+            msg = ml.get_mailmessage(
+                ml.subject, ml.body, request.user.email, to, bcc=bcc, cc=cc, attachments=ml.documents.all()
+            )
+        msg.send()
+
+        if exit_document:
+            for name, payload, mimetype in msg.attachments:
+                doc1.name = name
+                doc1.save()
+
+        email_messages = [msg]
+
+        mock_send.return_value.status_code = 200
+        mock_send.return_value.json.return_value = msg
+
+        num_sent = SendgridEmailBackend().send_messages(email_messages)
+        mock_send.assert_called()
+        assert mock_send.call_count == 1
+        assert num_sent == 1
+
+    def test_can_administrate_mail(self, mass_mail_factory):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        obj = mass_mail_factory()
+        result = can_administrate_mail(obj, request.user)
+        assert result

wbmailing/tests/signals.py

@@ -0,0 +1,124 @@
+from django.dispatch import receiver
+from wbcore.contrib.directory.models import EmailContact
+from wbcore.test.signals import (
+    custom_update_data_from_factory,
+    custom_update_kwargs,
+    get_custom_factory,
+)
+from wbmailing.factories import (
+    CustomMassMailFactory,
+    EmailContactFactory,
+    MailEventFactory,
+    MailFactory,
+    MailingListFactory,
+    MailingListSubscriberChangeRequestFactory,
+    MassMailFactory,
+    ToEmailMailFactory,
+)
+from wbmailing.models import MailingListSubscriberChangeRequest
+from wbmailing.viewsets import (
+    EmailContactMailingListModelViewSet,
+    MailEventMassMailMailModelViewSet,
+    MailingListEntryModelViewSet,
+    MailingListSubscriberChangeRequestModelViewSet,
+    MailingListSubscriberRequestEntryModelViewSet,
+    MailingListSubscriberRequestMailingListModelViewSet,
+    MailMailingListChartViewSet,
+    MailModelViewSet,
+    MailStatusMassMailModelViewSet,
+    MassMailModelViewSet,
+)
+
+# =================================================================================================================
+#                                              CUSTOM FACTORY
+# =================================================================================================================
+
+
+@receiver(get_custom_factory, sender=MassMailModelViewSet)
+def receive_factory_mass_mail(sender, *args, **kwargs):
+    return CustomMassMailFactory
+
+
+@receiver(get_custom_factory, sender=MailModelViewSet)
+def receive_factory_toemail(sender, *args, **kwargs):
+    return ToEmailMailFactory
+
+
+@receiver(get_custom_factory, sender=MailStatusMassMailModelViewSet)
+def receive_factory_email(sender, *args, **kwargs):
+    return EmailContactFactory
+
+
+# =================================================================================================================
+#                                              UPDATE DATA
+# =================================================================================================================
+
+
+@receiver(custom_update_data_from_factory, sender=MailingListSubscriberRequestMailingListModelViewSet)
+@receiver(custom_update_data_from_factory, sender=MailingListSubscriberRequestEntryModelViewSet)
+@receiver(custom_update_data_from_factory, sender=MailingListSubscriberChangeRequestModelViewSet)
+def receive_data_mailinglist_subscriber(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        obj.status = MailingListSubscriberChangeRequest.Status.APPROVED
+        obj.save()
+        # return {"mailing_list": obj.mailing_list.id }
+    return {}
+
+
+@receiver(custom_update_data_from_factory, sender=EmailContactMailingListModelViewSet)
+def receive_data_email_contact_mailinglist(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        mlscr = MailingListSubscriberChangeRequestFactory(
+            status=MailingListSubscriberChangeRequest.Status.APPROVED, mailing_list=obj.mailing_list
+        )
+        return {"email_contact": mlscr.email_contact.id}
+    return {}
+
+
+# =================================================================================================================
+#                                              UPDATE KWARGS
+# =================================================================================================================
+
+
+@receiver(custom_update_kwargs, sender=MailStatusMassMailModelViewSet)
+def receive_kwargs_mass_mail_mail(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        ml = MailingListFactory.create(email_contacts=[obj])
+        mass_mail = MassMailFactory.create(mailing_lists=[ml])
+        MailEventFactory.create(recipient=obj.address)
+        MailFactory.create(mass_mail=mass_mail, to_email=[obj])
+        return {"mass_mail_id": mass_mail.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=MailEventMassMailMailModelViewSet)
+def receive_kwargs_mail_event_massmail(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        return {"mass_mail_id": obj.mail.mass_mail.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=MailingListEntryModelViewSet)
+def receive_kwargs_mailing_list_entry(sender, *args, **kwargs):
+    if email_id := kwargs.get("email_contact_id", None):
+        ec = EmailContact.objects.get(id=email_id)
+        return {"entry_id": ec.entry.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=MailingListSubscriberRequestEntryModelViewSet)
+def receive_kwargs_mailing_list_subscriber_entry(sender, *args, **kwargs):
+    if kwargs.get("email_contact_id"):
+        sec = kwargs.get("email_contact_id")
+        ec = EmailContact.objects.filter(id=sec).first()
+        return {"entry_id": ec.entry.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=MailMailingListChartViewSet)
+def receive_kwargs_mail_mailing_list(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        ml = MailingListFactory()
+        obj.mass_mail.mailing_lists.add(ml)
+        return {"mailing_list_id": ml.id}
+    return {}

wbmailing/tests/test_serializers.py

@@ -0,0 +1,28 @@
+import pytest
+from django.core import mail
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.directory.factories import EmailContactFactory
+from wbcore.test.utils import get_kwargs
+from wbmailing.factories import CustomMassMailFactory
+from wbmailing.models import MassMail
+from wbmailing.viewsets.mails import MassMailModelViewSet
+
+
+@pytest.mark.django_db
+class TestSpecificSerializers:
+    @pytest.mark.parametrize("mvs, factory", [(MassMailModelViewSet, CustomMassMailFactory)])
+    def test_serializers_mail(self, mvs, factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        obj = factory(status=MassMail.Status.SENT)
+        EmailContactFactory(address=request.user.email)
+        nb_mail_send = len(mail.outbox)
+        request.query_params = {}
+        mvs.request = request
+        mvs.kwargs = get_kwargs(obj, mvs, request)
+        mvs.kwargs["pk"] = obj.pk
+        response = mvs().sendtestmail(request)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        assert len(mail.outbox) == nb_mail_send + 1