From 95c923ac22c2651fbd0321041e2080b2be4dbb10 Mon Sep 17 00:00:00 2001 From: SilviaAmAm Date: Tue, 14 Nov 2023 17:22:57 +0100 Subject: [PATCH] PREV --- src/openforms/emails/tests/test_tasks.py | 370 +++++++++++++++ .../tests/test_post_submission_event.py | 446 +++++++++++++++++- 2 files changed, 800 insertions(+), 16 deletions(-) diff --git a/src/openforms/emails/tests/test_tasks.py b/src/openforms/emails/tests/test_tasks.py index ab5b277b8f..fe6b4a1a84 100644 --- a/src/openforms/emails/tests/test_tasks.py +++ b/src/openforms/emails/tests/test_tasks.py @@ -4,14 +4,18 @@ from django.core import mail from django.test import TestCase, override_settings +from django.utils.translation import gettext as _ from django_yubin.models import Message from freezegun import freeze_time from openforms.config.models import GlobalConfiguration from openforms.logging.tests.factories import TimelineLogProxyFactory +from openforms.submissions.tasks import schedule_emails from openforms.submissions.tests.factories import SubmissionFactory +from ...payments.constants import PaymentStatus +from ...payments.tests.factories import SubmissionPaymentFactory from ..tasks import send_email_digest @@ -177,3 +181,369 @@ def test_no_recipients(self): send_email_digest() self.assertEqual(0, len(mail.outbox)) + + +@override_settings(CELERY_TASK_ALWAYS_EAGER=True, LANGUAGE_CODE="nl") +class QueueEmailsTaskTests(TestCase): + def test_submission_completed_cosign_and_payment_not_needed(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + } + ], + form__name="Pretty Form", + submitted_data={"email": "test@test.nl"}, + completed=True, + cosign_complete=False, + confirmation_email_sent=False, + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(1, len(mails)) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + + submission.refresh_from_db() + + self.assertTrue(submission.confirmation_email_sent) + self.assertFalse(submission.cosign_request_email_sent) + + def test_submission_completed_cosign_needed(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=False, + cosign_complete=False, + confirmation_email_sent=False, + form__name="Pretty Form", + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(2, len(mails)) + self.assertEqual(mails[0].subject, _("Co-sign request for Pretty Form")) + self.assertEqual(mails[0].to, ["cosign@test.nl"]) + self.assertEqual( + mails[1].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[1].to, ["test@test.nl"]) + self.assertEqual(mails[1].cc, []) + + cosign_info = _( + "This form will not be processed until it has been co-signed. A co-sign request was sent to %(cosigner_email)s." + ) % {"cosigner_email": "cosign@test.nl"} + + self.assertIn(cosign_info, mails[1].body.strip("\n")) + + submission.refresh_from_db() + + self.assertTrue(submission.cosign_request_email_sent) + self.assertTrue(submission.confirmation_email_sent) + + def test_submission_completed_payment_needed(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + ], + submitted_data={ + "email": "test@test.nl", + }, + completed=True, + confirmation_email_sent=False, + form__name="Pretty Form", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.started + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(1, len(mails)) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + + payment_info = _( + "Payment of EUR %(payment_price)s is required. You can pay using the link below." + ) % {"payment_price": "10,00"} + + self.assertIn(payment_info, mails[0].body.strip("\n")) + + submission.refresh_from_db() + + self.assertTrue(submission.confirmation_email_sent) + self.assertFalse(submission.cosign_request_email_sent) + + def test_submission_completed_cosign_and_payment_needed(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=False, + cosign_complete=False, + confirmation_email_sent=False, + form__name="Pretty Form", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.started + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(2, len(mails)) + self.assertEqual(mails[0].subject, _("Co-sign request for Pretty Form")) + self.assertEqual(mails[0].to, ["cosign@test.nl"]) + self.assertEqual( + mails[1].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[1].to, ["test@test.nl"]) + self.assertEqual(mails[1].cc, []) + + cosign_info = _( + "This form will not be processed until it has been co-signed. A co-sign request was sent to %(cosigner_email)s." + ) % {"cosigner_email": "cosign@test.nl"} + payment_info = _( + "Payment of EUR %(payment_price)s is required. You can pay using the link below." + ) % {"payment_price": "10,00"} + + self.assertIn(cosign_info, mails[1].body.strip("\n")) + self.assertIn(payment_info, mails[1].body.strip("\n")) + + submission.refresh_from_db() + + self.assertTrue(submission.cosign_request_email_sent) + self.assertTrue(submission.confirmation_email_sent) + + def test_cosign_done_payment_not_needed(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + confirmation_email_sent=True, + form__name="Pretty Form", + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(1, len(mails)) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, ["cosign@test.nl"]) + + cosign_info = _( + "This email is a confirmation that this form has been co-signed by %(cosigner_email)s and can now be processed." + ) % {"cosigner_email": "cosign@test.nl"} + + self.assertIn(cosign_info, mails[0].body.strip("\n")) + + submission.refresh_from_db() + + self.assertTrue(submission.cosign_confirmation_email_sent) + + def test_cosign_done_payment_needed_not_done(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + confirmation_email_sent=True, + form__name="Pretty Form", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.started + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(1, len(mails)) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, ["cosign@test.nl"]) + + cosign_info = _( + "This email is a confirmation that this form has been co-signed by %(cosigner_email)s and can now be processed." + ) % {"cosigner_email": "cosign@test.nl"} + payment_info = _( + "Payment of EUR %(payment_price)s is required. You can pay using the link below." + ) % {"payment_price": "10,00"} + + self.assertIn(cosign_info, mails[0].body.strip("\n")) + self.assertIn(payment_info, mails[0].body.strip("\n")) + + submission.refresh_from_db() + + self.assertTrue(submission.cosign_confirmation_email_sent) + self.assertFalse(submission.payment_complete_confirmation_email_sent) + + def test_cosign_done_payment_done(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + confirmation_email_sent=True, + form__name="Pretty Form", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with self.captureOnCommitCallbacks(execute=True): + schedule_emails(submission.id) + + mails = mail.outbox + + self.assertEqual(1, len(mails)) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, ["cosign@test.nl"]) + + cosign_info = _( + "This email is a confirmation that this form has been co-signed by %(cosigner_email)s and can now be processed." + ) % {"cosigner_email": "cosign@test.nl"} + payment_info = _( + "Payment of EUR %(payment_price)s is required. You can pay using the link below." + ) % {"payment_price": "10,00"} + + self.assertIn(cosign_info, mails[0].body.strip("\n")) + self.assertNotIn(payment_info, mails[0].body.strip("\n")) + + submission.refresh_from_db() + + self.assertTrue(submission.cosign_confirmation_email_sent) + self.assertTrue(submission.payment_complete_confirmation_email_sent) + + # + # Status: submission completed, payment done + # + def test_payment_done_cosign_not_needed(self): + pass + + def test_payment_done_cosign_needed_not_done(self): + pass + + def test_payment_done_cosign_done(self): + pass + + # + # Status: submission completed, payment done, cosign done. Registration failed + # + def test_confirmation_email_not_sent_again(self): + pass diff --git a/src/openforms/submissions/tests/test_post_submission_event.py b/src/openforms/submissions/tests/test_post_submission_event.py index eb91e15097..babc6a7b52 100644 --- a/src/openforms/submissions/tests/test_post_submission_event.py +++ b/src/openforms/submissions/tests/test_post_submission_event.py @@ -1,3 +1,4 @@ +from unittest import skip from unittest.mock import patch from django.core import mail @@ -10,6 +11,7 @@ from openforms.payments.constants import PaymentStatus from openforms.payments.tests.factories import SubmissionPaymentFactory +from ..constants import RegistrationStatuses from ..models import SubmissionReport from ..tasks import on_post_submission_event from .factories import SubmissionFactory @@ -334,39 +336,451 @@ def test_payment_needed_not_done(self): self.assertEqual(mails[0].cc, ["cosign@test.nl"]) self.assertNotEqual(submission.auth_info.value, "111222333") + # TODO There is a status to check if the payment status was updated!! def test_payment_needed_done(self): - pass + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + self.assertTrue(SubmissionReport.objects.filter(submission=submission).exists()) + mock_registration.assert_called() + mock_payment_status_update.assert_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, ["cosign@test.nl"]) + self.assertNotEqual(submission.auth_info.value, "111222333") # - # Event: payment done (new flow) + # Event: payment done (old flow) # def test_cosign_not_needed(self): - pass + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + ], + submitted_data={"email": "test@test.nl"}, + completed=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + self.assertTrue(SubmissionReport.objects.filter(submission=submission).exists()) + mock_registration.assert_called() + mock_payment_status_update.assert_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + self.assertNotEqual(submission.auth_info.value, "111222333") def test_cosign_needed_not_done(self): - pass + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=False, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + self.assertTrue(SubmissionReport.objects.filter(submission=submission).exists()) + mock_registration.assert_not_called() + mock_payment_status_update.assert_not_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + self.assertEqual(submission.auth_info.value, "111222333") def test_cosign_needed_done(self): - pass + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + self.assertTrue(SubmissionReport.objects.filter(submission=submission).exists()) + mock_registration.assert_called() + mock_payment_status_update.assert_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, ["cosign@test.nl"]) + self.assertNotEqual(submission.auth_info.value, "111222333") # - # Event: payment done (old flow) + # Event: payment done (new flow) - TODO # - def test_cosign_not_needed_old(self): - pass + @skip("New flow not yet implemented") + def test_cosign_not_needed_new(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + ], + submitted_data={"email": "test@test.nl"}, + completed=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) - def test_cosign_needed_not_done_old(self): - pass + submission.refresh_from_db() - def test_cosign_needed_done_old(self): - pass + self.assertTrue(SubmissionReport.objects.filter(submission=submission).exists()) + mock_registration.assert_called() + mock_payment_status_update.assert_not_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + self.assertNotEqual(submission.auth_info.value, "111222333") + + @skip("New flow not yet implemented") + def test_cosign_needed_done_new(self): + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_confirmation_email_sent=True, + cosign_complete=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + self.assertTrue(SubmissionReport.objects.filter(submission=submission).exists()) + mock_registration.assert_called() + mock_payment_status_update.assert_not_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + self.assertNotEqual(submission.auth_info.value, "111222333") # - # Event: on retry + # Event: on retry (old flow) # - def test_triggered_by_failed_registration(self): - pass + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + cosign_confirmation_email_sent=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + needs_on_completion_retry=True, + registration_status=RegistrationStatuses.failed, + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + mock_registration.assert_called() + mock_payment_status_update.assert_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + self.assertNotEqual(submission.auth_info.value, "111222333") def test_triggered_by_failed_payment_status_update(self): - pass + submission = SubmissionFactory.from_components( + components_list=[ + { + "key": "email", + "type": "email", + "label": "Email", + "confirmationRecipient": True, + }, + { + "key": "cosign", + "type": "cosign", + "label": "Cosign component", + "validate": {"required": True}, + }, + ], + submitted_data={"email": "test@test.nl", "cosign": "cosign@test.nl"}, + completed=True, + cosign_request_email_sent=True, + cosign_complete=True, + cosign_confirmation_email_sent=True, + form__registration_backend="email", + form__registration_backend_options={"to_emails": ["test@registration.nl"]}, + form__name="Pretty Form", + auth_info__attribute=AuthAttribute.bsn, + auth_info__value="111222333", + form__product__price=10, + form__payment_backend="demo", + needs_on_completion_retry=True, + registration_status=RegistrationStatuses.success, + ) + SubmissionPaymentFactory.create( + submission=submission, amount=10, status=PaymentStatus.completed + ) + + with patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.register_submission" + ) as mock_registration, patch( + "openforms.registrations.contrib.email.plugin.EmailRegistration.update_payment_status" + ) as mock_payment_status_update: + with self.captureOnCommitCallbacks(execute=True): + on_post_submission_event(submission.id) + + submission.refresh_from_db() + + mock_registration.assert_not_called() + mock_payment_status_update.assert_called() + + mails = mail.outbox + + self.assertEqual(len(mails), 1) + self.assertEqual( + mails[0].subject, "Bevestiging van uw inzending van Pretty Form" + ) + self.assertEqual(mails[0].to, ["test@test.nl"]) + self.assertEqual(mails[0].cc, []) + self.assertNotEqual(submission.auth_info.value, "111222333")