import json
from decimal import Decimal

from django.core import mail
from django.core.exceptions import ImproperlyConfigured
from django.test import SimpleTestCase, override_settings, tag

from anymail.exceptions import (
    AnymailAPIError,
    AnymailInvalidAddress,
    AnymailRecipientsRefused,
    AnymailSerializationError,
    AnymailUnsupportedFeature,
)
from anymail.message import AnymailMessage, attach_inline_image

from .mock_requests_backend import (
    RequestsBackendMockAPITestCase,
    SessionSharingTestCases,
)
from .utils import (
    AnymailTestMixin,
    create_text_attachment,
    decode_att,
    sample_image_content,
)


@tag("postmark")
@override_settings(
    EMAIL_BACKEND="anymail.backends.postmark.EmailBackend",
    ANYMAIL={"POSTMARK_SERVER_TOKEN": "test_server_token"},
)
class PostmarkBackendMockAPITestCase(RequestsBackendMockAPITestCase):
    DEFAULT_RAW_RESPONSE = b"""{
        "To": "to@example.com",
        "SubmittedAt": "2016-03-12T15:27:50.4468803-05:00",
        "MessageID": "b4007d94-33f1-4e78-a783-97417d6c80e6",
        "ErrorCode":0,
        "Message":"OK"
    }"""

    def setUp(self):
        super().setUp()
        # Simple message useful for many tests
        self.message = mail.EmailMultiAlternatives(
            "Subject", "Text Body", "from@example.com", ["to@example.com"]
        )


@tag("postmark")
class PostmarkBackendStandardEmailTests(PostmarkBackendMockAPITestCase):
    """Test backend support for Django standard email features"""

    def test_send_mail(self):
        """Test basic API for simple send"""
        mail.send_mail(
            "Subject here",
            "Here is the message.",
            "from@sender.example.com",
            ["to@example.com"],
            fail_silently=False,
        )
        self.assert_esp_called("/email")
        headers = self.get_api_call_headers()
        self.assertEqual(headers["X-Postmark-Server-Token"], "test_server_token")
        data = self.get_api_call_json()
        self.assertEqual(data["Subject"], "Subject here")
        self.assertEqual(data["TextBody"], "Here is the message.")
        self.assertEqual(data["From"], "from@sender.example.com")
        self.assertEqual(data["To"], "to@example.com")

    def test_name_addr(self):
        """Make sure RFC2822 name-addr format (with display-name) is allowed

        (Test both sender and recipient addresses)
        """
        msg = mail.EmailMessage(
            "Subject",
            "Message",
            "From Name <from@example.com>",
            ["Recipient #1 <to1@example.com>", "to2@example.com"],
            cc=["Carbon Copy <cc1@example.com>", "cc2@example.com"],
            bcc=["Blind Copy <bcc1@example.com>", "bcc2@example.com"],
        )
        msg.send()
        data = self.get_api_call_json()
        self.assertEqual(data["From"], "From Name <from@example.com>")
        self.assertEqual(data["To"], "Recipient #1 <to1@example.com>, to2@example.com")
        self.assertEqual(data["Cc"], "Carbon Copy <cc1@example.com>, cc2@example.com")
        self.assertEqual(data["Bcc"], "Blind Copy <bcc1@example.com>, bcc2@example.com")

    def test_email_message(self):
        email = mail.EmailMessage(
            "Subject",
            "Body goes here",
            "from@example.com",
            ["to1@example.com", "Also To <to2@example.com>"],
            bcc=["bcc1@example.com", "Also BCC <bcc2@example.com>"],
            cc=["cc1@example.com", "Also CC <cc2@example.com>"],
            headers={
                "Reply-To": "another@example.com",
                "X-MyHeader": "my value",
                # should override backend msgid:
                "Message-ID": "mycustommsgid@sales.example.com",
            },
        )
        email.send()
        data = self.get_api_call_json()
        self.assertEqual(data["Subject"], "Subject")
        self.assertEqual(data["TextBody"], "Body goes here")
        self.assertEqual(data["From"], "from@example.com")
        self.assertEqual(data["To"], "to1@example.com, Also To <to2@example.com>")
        self.assertEqual(data["Bcc"], "bcc1@example.com, Also BCC <bcc2@example.com>")
        self.assertEqual(data["Cc"], "cc1@example.com, Also CC <cc2@example.com>")
        self.assertEqual(data["ReplyTo"], "another@example.com")
        self.assertCountEqual(
            data["Headers"],
            [
                {"Name": "Message-ID", "Value": "mycustommsgid@sales.example.com"},
                {"Name": "X-MyHeader", "Value": "my value"},
            ],
        )

    def test_html_message(self):
        text_content = "This is an important message."
        html_content = "<p>This is an <strong>important</strong> message.</p>"
        email = mail.EmailMultiAlternatives(
            "Subject", text_content, "from@example.com", ["to@example.com"]
        )
        email.attach_alternative(html_content, "text/html")
        email.send()
        data = self.get_api_call_json()
        self.assertEqual(data["TextBody"], text_content)
        self.assertEqual(data["HtmlBody"], html_content)
        # Don't accidentally send the html part as an attachment:
        self.assertNotIn("Attachments", data)

    def test_html_only_message(self):
        html_content = "<p>This is an <strong>important</strong> message.</p>"
        email = mail.EmailMessage(
            "Subject", html_content, "from@example.com", ["to@example.com"]
        )
        email.content_subtype = "html"  # Main content is now text/html
        email.send()
        data = self.get_api_call_json()
        self.assertNotIn("TextBody", data)
        self.assertEqual(data["HtmlBody"], html_content)

    def test_extra_headers(self):
        self.message.extra_headers = {"X-Custom": "string", "X-Num": 123}
        self.message.send()
        data = self.get_api_call_json()
        self.assertCountEqual(
            data["Headers"],
            [{"Name": "X-Custom", "Value": "string"}, {"Name": "X-Num", "Value": 123}],
        )

    def test_extra_headers_serialization_error(self):
        self.message.extra_headers = {"X-Custom": Decimal(12.5)}
        with self.assertRaisesMessage(AnymailSerializationError, "Decimal"):
            self.message.send()

    def test_reply_to(self):
        email = mail.EmailMessage(
            "Subject",
            "Body goes here",
            "from@example.com",
            ["to1@example.com"],
            reply_to=["reply@example.com", "Other <reply2@example.com>"],
            headers={"X-Other": "Keep"},
        )
        email.send()
        data = self.get_api_call_json()
        self.assertEqual(
            data["ReplyTo"], "reply@example.com, Other <reply2@example.com>"
        )
        # don't lose other headers:
        self.assertEqual(data["Headers"], [{"Name": "X-Other", "Value": "Keep"}])

    def test_reply_to_header(self):
        # Reply-To needs to be moved out of headers, into dedicated param
        email = mail.EmailMessage(
            "Subject",
            "Body goes here",
            "from@example.com",
            ["to1@example.com"],
            headers={
                "reply-to": "reply@example.com, Other <reply2@example.com>",
                "X-Other": "Keep",
            },
        )
        email.send()
        data = self.get_api_call_json()
        self.assertEqual(
            data["ReplyTo"], "reply@example.com, Other <reply2@example.com>"
        )
        # don't lose other headers:
        self.assertEqual(data["Headers"], [{"Name": "X-Other", "Value": "Keep"}])

    def test_non_ascii_headers(self):
        # Postmark correctly encodes non-ASCII display-names and other headers
        # (but requires IDNA encoding for non-ASCII domain names).
        email = mail.EmailMessage(
            from_email='"Odesílatel, z adresy" <from@příklad.example.cz>',
            to=['"Příjemce, na adresu" <to@příklad.example.cz>'],
            subject="Předmět e-mailu",
            reply_to=['"Odpověď, adresa" <reply@příklad.example.cz>'],
            headers={"X-Extra": "Další"},
            body="Prostý text",
        )
        email.send()
        data = self.get_api_call_json()
        self.assertEqual(
            data["From"], '"Odesílatel, z adresy" <from@xn--pklad-zsa96e.example.cz>'
        )
        self.assertEqual(
            data["To"], '"Příjemce, na adresu" <to@xn--pklad-zsa96e.example.cz>'
        )
        self.assertEqual(data["Subject"], "Předmět e-mailu")
        self.assertEqual(
            data["ReplyTo"], '"Odpověď, adresa" <reply@xn--pklad-zsa96e.example.cz>'
        )
        self.assertEqual(data["Headers"], [{"Name": "X-Extra", "Value": "Další"}])

    def test_attachments(self):
        # Postmark supports non-utf-8 content with charset in the `type` field.
        # Postmark does not require attachment filenames. It allows non-ASCII
        # filenames (though incorrectly applies rfc2047 when sending).
        text_content = "pièce jointe\n"
        self.message.attach(
            create_text_attachment("pièce jointe\n", charset="iso-8859-1")
        )
        self.message.attach("émoticône.img", b";-)", "image/x-emoticon")
        image_data = sample_image_content()
        cid = attach_inline_image(self.message, image_data, "test.png")

        self.message.send()
        data = self.get_api_call_json()

        attachments = data["Attachments"]
        self.assertEqual(len(attachments), 3)
        self.assertEqual(attachments[0]["Name"], "")  # no filename
        self.assertEqual(
            attachments[0]["ContentType"], 'text/plain; charset="iso-8859-1"'
        )
        self.assertEqual(
            decode_att(attachments[0]["Content"]).decode("iso-8859-1"), text_content
        )
        self.assertNotIn("ContentID", attachments[0])

        # ContentType inferred from filename:
        self.assertEqual(attachments[1]["ContentType"], "image/x-emoticon")
        self.assertEqual(attachments[1]["Name"], "émoticône.img")
        self.assertEqual(decode_att(attachments[1]["Content"]), b";-)")
        # make sure image not treated as inline:
        self.assertNotIn("ContentID", attachments[1])

        self.assertEqual(attachments[2]["ContentType"], "image/png")
        self.assertEqual(attachments[2]["Name"], "test.png")
        self.assertEqual(decode_att(attachments[2]["Content"]), image_data)
        self.assertEqual(attachments[2]["ContentID"], f"cid:{cid}")

    def test_multiple_html_alternatives(self):
        # Multiple alternatives not allowed
        self.message.attach_alternative("<p>First html is OK</p>", "text/html")
        self.message.attach_alternative("<p>But not second html</p>", "text/html")
        with self.assertRaises(AnymailUnsupportedFeature):
            self.message.send()

    def test_html_alternative(self):
        # Only html alternatives allowed
        self.message.attach_alternative("{'not': 'allowed'}", "application/json")
        with self.assertRaises(AnymailUnsupportedFeature):
            self.message.send()

    def test_alternatives_fail_silently(self):
        # Make sure fail_silently is respected
        self.message.attach_alternative("{'not': 'allowed'}", "application/json")
        sent = self.message.send(fail_silently=True)
        self.assert_esp_not_called("API should not be called when send fails silently")
        self.assertEqual(sent, 0)

    def test_suppress_empty_address_lists(self):
        """Empty to, cc, bcc, and reply_to shouldn't generate empty fields"""
        self.message.send()
        data = self.get_api_call_json()
        self.assertNotIn("Cc", data)
        self.assertNotIn("Bcc", data)
        self.assertNotIn("ReplyTo", data)

        # Test empty `to`--but send requires at least one recipient somewhere (like cc)
        self.message.to = []
        self.message.cc = ["cc@example.com"]
        self.message.send()
        data = self.get_api_call_json()
        self.assertNotIn("To", data)

    def test_multiple_from_emails(self):
        """
        Postmark accepts multiple addresses in from_email (though only uses the first)
        """
        self.message.from_email = 'first@example.com, "From, also" <second@example.com>'
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(
            data["From"], 'first@example.com, "From, also" <second@example.com>'
        )

        # Make sure the far-more-likely scenario of a single from_email
        # with an unquoted display-name issues a reasonable error:
        self.message.from_email = "Unquoted, display-name <from@example.com>"
        with self.assertRaises(AnymailInvalidAddress):
            self.message.send()

    def test_api_failure(self):
        self.set_mock_response(status_code=500)
        with self.assertRaisesMessage(AnymailAPIError, "Postmark API response 500"):
            mail.send_mail("Subject", "Body", "from@example.com", ["to@example.com"])

        # Make sure fail_silently is respected
        self.set_mock_response(status_code=500)
        sent = mail.send_mail(
            "Subject",
            "Body",
            "from@example.com",
            ["to@example.com"],
            fail_silently=True,
        )
        self.assertEqual(sent, 0)

    def test_api_error_includes_details(self):
        """AnymailAPIError should include ESP's error message"""
        # JSON error response:
        error_response = b"""{
            "ErrorCode": 451,
            "Message": "Helpful explanation from Postmark."
        }"""
        self.set_mock_response(status_code=200, raw=error_response)
        with self.assertRaisesMessage(
            AnymailAPIError, "Helpful explanation from Postmark"
        ):
            self.message.send()

        # Non-JSON error response:
        self.set_mock_response(status_code=500, raw=b"Ack! Bad proxy!")
        with self.assertRaisesMessage(AnymailAPIError, "Ack! Bad proxy!"):
            self.message.send()

        # No content in the error response:
        self.set_mock_response(status_code=502, raw=None)
        with self.assertRaises(AnymailAPIError):
            self.message.send()


@tag("postmark")
class PostmarkBackendAnymailFeatureTests(PostmarkBackendMockAPITestCase):
    """Test backend support for Anymail added features"""

    def test_envelope_sender(self):
        # Postmark doesn't allow overriding envelope sender on individual messages.
        # You can configure a custom return-path domain for each server in their
        # control panel.
        self.message.envelope_sender = "anything@bounces.example.com"
        with self.assertRaisesMessage(AnymailUnsupportedFeature, "envelope_sender"):
            self.message.send()

    def test_metadata(self):
        self.message.metadata = {"user_id": "12345", "items": 6}
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(data["Metadata"], {"user_id": "12345", "items": 6})

    def test_send_at(self):
        self.message.send_at = 1651820889  # 2022-05-06 07:08:09 UTC
        with self.assertRaisesMessage(AnymailUnsupportedFeature, "send_at"):
            self.message.send()

    def test_tags(self):
        self.message.tags = ["receipt"]
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(data["Tag"], "receipt")

        self.message.tags = ["receipt", "repeat-user"]
        with self.assertRaisesMessage(AnymailUnsupportedFeature, "multiple tags"):
            self.message.send()

    def test_track_opens(self):
        self.message.track_opens = True
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(data["TrackOpens"], True)

    def test_track_clicks(self):
        self.message.track_clicks = True
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(data["TrackLinks"], "HtmlAndText")

        # Also explicit "None" for False (to override server default)
        self.message.track_clicks = False
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(data["TrackLinks"], "None")

    def test_template(self):
        message = AnymailMessage(
            # Omit subject and body (Postmark prohibits them with templates)
            from_email="from@example.com",
            to=["to@example.com"],
            template_id=1234567,
            merge_global_data={"name": "Alice", "group": "Developers"},
        )
        message.send()
        self.assert_esp_called("/email/withTemplate/")
        data = self.get_api_call_json()
        self.assertEqual(data["TemplateId"], 1234567)
        self.assertEqual(
            data["TemplateModel"], {"name": "Alice", "group": "Developers"}
        )
        # Make sure Django default subject and body didn't end up in the payload:
        self.assertNotIn("Subject", data)
        self.assertNotIn("HtmlBody", data)
        self.assertNotIn("TextBody", data)

    def test_template_alias(self):
        # Anymail template_id can be either Postmark TemplateId or TemplateAlias
        message = AnymailMessage(
            from_email="from@example.com",
            to=["to@example.com"],
            template_id="welcome-message",
        )
        message.send()
        self.assert_esp_called("/email/withTemplate/")
        data = self.get_api_call_json()
        self.assertEqual(data["TemplateAlias"], "welcome-message")
        # Postmark requires TemplateModel (can be empty) with TemplateId/TemplateAlias
        self.assertEqual(data["TemplateModel"], {})

    def test_template_multiple_recipients(self):
        # This is a non-batch (no merge_data) template send
        message = AnymailMessage(
            from_email="from@example.com",
            to=["to@example.com", "Also to <to2@example.com>"],
            template_id=1234567,
        )
        message.send()
        self.assert_esp_called("/email/withTemplate/")
        data = self.get_api_call_json()
        self.assertEqual(data["To"], "to@example.com, Also to <to2@example.com>")
        self.assertEqual(data["TemplateId"], 1234567)

    _mock_batch_response = json.dumps(
        [
            {
                "ErrorCode": 0,
                "Message": "OK",
                "To": "alice@example.com",
                "SubmittedAt": "2016-03-12T15:27:50.4468803-05:00",
                "MessageID": "b7bc2f4a-e38e-4336-af7d-e6c392c2f817",
            },
            {
                "ErrorCode": 0,
                "Message": "OK",
                "To": "bob@example.com",
                "SubmittedAt": "2016-03-12T15:27:50.4468803-05:00",
                "MessageID": "e2ecbbfc-fe12-463d-b933-9fe22915106d",
            },
        ]
    ).encode("utf-8")

    def test_merge_data(self):
        self.set_mock_response(raw=self._mock_batch_response)
        message = AnymailMessage(
            from_email="from@example.com",
            # Postmark only supports merge_data content in a template
            template_id=1234567,
            to=["alice@example.com", "Bob <bob@example.com>"],
            merge_data={
                "alice@example.com": {"name": "Alice", "group": "Developers"},
                "bob@example.com": {"name": "Bob"},  # and leave group undefined
                "nobody@example.com": {"name": "Not a recipient for this message"},
            },
            merge_global_data={"group": "Users", "site": "ExampleCo"},
        )
        message.send()

        self.assert_esp_called("/email/batchWithTemplates")
        data = self.get_api_call_json()
        messages = data["Messages"]
        self.assertEqual(len(messages), 2)
        self.assertEqual(
            messages[0],
            {
                "From": "from@example.com",
                "To": "alice@example.com",
                "TemplateId": 1234567,
                "TemplateModel": {
                    "name": "Alice",
                    "group": "Developers",
                    "site": "ExampleCo",
                },
            },
        )
        self.assertEqual(
            messages[1],
            {
                "From": "from@example.com",
                "To": "Bob <bob@example.com>",
                "TemplateId": 1234567,
                "TemplateModel": {"name": "Bob", "group": "Users", "site": "ExampleCo"},
            },
        )

        recipients = message.anymail_status.recipients
        self.assertEqual(recipients["alice@example.com"].status, "sent")
        self.assertEqual(
            recipients["alice@example.com"].message_id,
            "b7bc2f4a-e38e-4336-af7d-e6c392c2f817",
        )
        self.assertEqual(recipients["bob@example.com"].status, "sent")
        self.assertEqual(
            recipients["bob@example.com"].message_id,
            "e2ecbbfc-fe12-463d-b933-9fe22915106d",
        )

    def test_merge_data_single_recipient(self):
        self.set_mock_response(raw=self._mock_batch_response)
        message = AnymailMessage(
            from_email="from@example.com",
            # Postmark only supports merge_data content in a template:
            template_id=1234567,
            to=["alice@example.com"],
            merge_data={
                "alice@example.com": {"name": "Alice", "group": "Developers"},
                "nobody@example.com": {"name": "Not a recipient for this message"},
            },
            merge_global_data={"group": "Users", "site": "ExampleCo"},
        )
        message.send()

        # because merge_data is set, it's treated as a batch send
        self.assert_esp_called("/email/batchWithTemplates")
        data = self.get_api_call_json()

        self.assertEqual(
            data,
            {
                "Messages": [
                    {
                        "From": "from@example.com",
                        "To": "alice@example.com",
                        "TemplateId": 1234567,
                        "TemplateModel": {
                            "name": "Alice",
                            "group": "Developers",
                            "site": "ExampleCo",
                        },
                    }
                ]
            },
        )

        recipients = message.anymail_status.recipients
        self.assertEqual(recipients["alice@example.com"].status, "sent")
        self.assertEqual(
            recipients["alice@example.com"].message_id,
            "b7bc2f4a-e38e-4336-af7d-e6c392c2f817",
        )

    def test_merge_data_no_template(self):
        # merge_data={} can be used to force batch sending without a template
        self.set_mock_response(raw=self._mock_batch_response)
        message = AnymailMessage(
            from_email="from@example.com",
            to=["alice@example.com", "Bob <bob@example.com>"],
            merge_data={},
            subject="Test batch send",
            body="Test body",
        )
        message.send()

        self.assert_esp_called("/email/batch")
        data = self.get_api_call_json()
        self.assertEqual(len(data), 2)
        self.assertEqual(
            data[0],
            {
                "From": "from@example.com",
                "To": "alice@example.com",
                "Subject": "Test batch send",
                "TextBody": "Test body",
            },
        )
        self.assertEqual(
            data[1],
            {
                "From": "from@example.com",
                "To": "Bob <bob@example.com>",
                "Subject": "Test batch send",
                "TextBody": "Test body",
            },
        )

        recipients = message.anymail_status.recipients
        self.assertEqual(recipients["alice@example.com"].status, "sent")
        self.assertEqual(
            recipients["alice@example.com"].message_id,
            "b7bc2f4a-e38e-4336-af7d-e6c392c2f817",
        )
        self.assertEqual(recipients["bob@example.com"].status, "sent")
        self.assertEqual(
            recipients["bob@example.com"].message_id,
            "e2ecbbfc-fe12-463d-b933-9fe22915106d",
        )

    def test_merge_metadata(self):
        self.set_mock_response(raw=self._mock_batch_response)
        self.message.to = ["alice@example.com", "Bob <bob@example.com>"]
        self.message.merge_metadata = {
            "alice@example.com": {"order_id": 123, "tier": "premium"},
            "bob@example.com": {"order_id": 678},
        }
        self.message.metadata = {"notification_batch": "zx912"}
        self.message.send()

        self.assert_esp_called("/email/batch")
        data = self.get_api_call_json()
        self.assertEqual(len(data), 2)
        self.assertEqual(data[0]["To"], "alice@example.com")
        # metadata and merge_metadata[recipient] are combined:
        self.assertEqual(
            data[0]["Metadata"],
            {"order_id": 123, "tier": "premium", "notification_batch": "zx912"},
        )
        self.assertEqual(data[1]["To"], "Bob <bob@example.com>")
        self.assertEqual(
            data[1]["Metadata"], {"order_id": 678, "notification_batch": "zx912"}
        )

    def test_merge_metadata_with_template(self):
        self.set_mock_response(raw=self._mock_batch_response)
        self.message.to = ["alice@example.com", "Bob <bob@example.com>"]
        self.message.template_id = 1234567
        self.message.merge_metadata = {
            "alice@example.com": {"order_id": 123},
            "bob@example.com": {"order_id": 678, "tier": "premium"},
        }
        self.message.send()

        self.assert_esp_called("/email/batchWithTemplates")
        data = self.get_api_call_json()
        messages = data["Messages"]
        self.assertEqual(len(messages), 2)
        self.assertEqual(messages[0]["To"], "alice@example.com")
        # metadata and merge_metadata[recipient] are combined:
        self.assertEqual(messages[0]["Metadata"], {"order_id": 123})
        self.assertEqual(messages[1]["To"], "Bob <bob@example.com>")
        self.assertEqual(messages[1]["Metadata"], {"order_id": 678, "tier": "premium"})

    def test_merge_headers(self):
        self.message.to = ["alice@example.com", "Bob <bob@example.com>"]
        self.message.extra_headers = {
            "List-Unsubscribe-Post": "List-Unsubscribe=One-Click",
            "List-Unsubscribe": "<mailto:unsubscribe@example.com>",
        }
        self.message.merge_headers = {
            "alice@example.com": {
                "List-Unsubscribe": "<https://example.com/a/>",
            },
            "bob@example.com": {
                "List-Unsubscribe": "<https://example.com/b/>",
            },
        }
        self.message.send()

        self.assert_esp_called("/email/batch")
        data = self.get_api_call_json()
        self.assertEqual(len(data), 2)
        # Global and merge headers are combined:
        self.assertEqual(data[0]["To"], "alice@example.com")
        self.assertCountEqual(
            data[0]["Headers"],
            [
                {"Name": "List-Unsubscribe", "Value": "<https://example.com/a/>"},
                {
                    "Name": "List-Unsubscribe-Post",
                    "Value": "List-Unsubscribe=One-Click",
                },
            ],
        )
        self.assertEqual(data[1]["To"], "Bob <bob@example.com>")
        self.assertCountEqual(
            data[1]["Headers"],
            [
                {"Name": "List-Unsubscribe", "Value": "<https://example.com/b/>"},
                {
                    "Name": "List-Unsubscribe-Post",
                    "Value": "List-Unsubscribe=One-Click",
                },
            ],
        )

    def test_default_omits_options(self):
        """Make sure by default we don't send any ESP-specific options.

        Options not specified by the caller should be omitted entirely from
        the API call (*not* sent as False or empty). This ensures
        that your ESP account settings apply by default.
        """
        self.message.send()
        data = self.get_api_call_json()
        self.assertNotIn("Metadata", data)
        self.assertNotIn("Tag", data)
        self.assertNotIn("TemplateId", data)
        self.assertNotIn("TemplateModel", data)
        self.assertNotIn("TrackOpens", data)
        self.assertNotIn("TrackLinks", data)

    def test_esp_extra(self):
        self.message.esp_extra = {
            "FuturePostmarkOption": "some-value",
        }
        self.message.send()
        data = self.get_api_call_json()
        self.assertEqual(data["FuturePostmarkOption"], "some-value")

    def test_message_server_token(self):
        # Can override server-token on a per-message basis:
        self.message.esp_extra = {
            "server_token": "token_for_this_message_only",
        }
        self.message.send()
        headers = self.get_api_call_headers()
        self.assertEqual(
            headers["X-Postmark-Server-Token"], "token_for_this_message_only"
        )
        data = self.get_api_call_json()
        self.assertNotIn("server_token", data)  # not in the json

    # noinspection PyUnresolvedReferences
    def test_send_attaches_anymail_status(self):
        """The anymail_status should be attached to the message when it is sent"""
        response_content = b"""{
            "MessageID":"abcdef01-2345-6789-0123-456789abcdef",
            "ErrorCode":0,
            "To":"Recipient <to1@example.com>",
            "Message":"OK"
        }"""
        self.set_mock_response(raw=response_content)
        msg = mail.EmailMessage(
            "Subject",
            "Message",
            "from@example.com",
            ["Recipient <to1@example.com>"],
        )
        sent = msg.send()
        self.assertEqual(sent, 1)
        self.assertEqual(msg.anymail_status.status, {"sent"})
        self.assertEqual(
            msg.anymail_status.message_id, "abcdef01-2345-6789-0123-456789abcdef"
        )
        self.assertEqual(
            msg.anymail_status.recipients["to1@example.com"].status, "sent"
        )
        self.assertEqual(
            msg.anymail_status.recipients["to1@example.com"].message_id,
            "abcdef01-2345-6789-0123-456789abcdef",
        )
        self.assertEqual(msg.anymail_status.esp_response.content, response_content)

    # noinspection PyUnresolvedReferences
    def test_send_without_to_attaches_anymail_status(self):
        """The anymail_status should be attached even if there are no `to` recipients"""
        # Despite Postmark's docs, the "To" field is *not* required
        # if cc or bcc is provided.
        response_content = b"""{
            "SubmittedAt": "2019-01-28T13:54:35.5813997-05:00",
            "MessageID":"abcdef01-2345-6789-0123-456789abcdef",
            "ErrorCode":0,
            "Message":"OK"
        }"""
        self.set_mock_response(raw=response_content)
        msg = mail.EmailMessage(
            "Subject",
            "Message",
            "from@example.com",
            cc=["cc@example.com"],
        )
        sent = msg.send()
        self.assertEqual(sent, 1)
        self.assertEqual(msg.anymail_status.status, {"sent"})
        self.assertEqual(
            msg.anymail_status.message_id, "abcdef01-2345-6789-0123-456789abcdef"
        )
        self.assertEqual(msg.anymail_status.recipients["cc@example.com"].status, "sent")
        self.assertEqual(
            msg.anymail_status.recipients["cc@example.com"].message_id,
            "abcdef01-2345-6789-0123-456789abcdef",
        )
        self.assertEqual(msg.anymail_status.esp_response.content, response_content)

    # noinspection PyUnresolvedReferences
    def test_send_failed_anymail_status(self):
        """If the send fails, anymail_status should contain initial values"""
        self.set_mock_response(status_code=500)
        sent = self.message.send(fail_silently=True)
        self.assertEqual(sent, 0)
        self.assertIsNone(self.message.anymail_status.status)
        self.assertIsNone(self.message.anymail_status.message_id)
        self.assertEqual(self.message.anymail_status.recipients, {})
        self.assertIsNone(self.message.anymail_status.esp_response)

    # noinspection PyUnresolvedReferences
    def test_send_unparsable_response(self):
        """
        If the send succeeds, but a non-JSON API response, should raise an API exception
        """
        mock_response = self.set_mock_response(
            status_code=200, raw=b"yikes, this isn't a real response"
        )
        with self.assertRaises(AnymailAPIError):
            self.message.send()
        self.assertIsNone(self.message.anymail_status.status)
        self.assertIsNone(self.message.anymail_status.message_id)
        self.assertEqual(self.message.anymail_status.recipients, {})
        self.assertEqual(self.message.anymail_status.esp_response, mock_response)

    def test_json_serialization_errors(self):
        """Try to provide more information about non-json-serializable data"""
        self.message.tags = [Decimal("19.99")]  # yeah, don't do this
        with self.assertRaises(AnymailSerializationError) as cm:
            self.message.send()
            print(self.get_api_call_json())
        err = cm.exception
        self.assertIsInstance(err, TypeError)  # compatibility with json.dumps
        # our added context:
        self.assertIn("Don't know how to send this data to Postmark", str(err))
        # original message:
        self.assertRegex(str(err), r"Decimal.*is not JSON serializable")


@tag("postmark")
class PostmarkBackendRecipientsRefusedTests(PostmarkBackendMockAPITestCase):
    """
    Should raise AnymailRecipientsRefused when *all* recipients are rejected or invalid
    """

    def test_recipients_inactive(self):
        self.set_mock_response(
            status_code=422,
            raw=b'{"ErrorCode":406,'
            b'"Message":"You tried to send to a recipient'
            b" that has been marked as inactive.\\n"
            b"Found inactive addresses: hardbounce@example.com, spam@example.com.\\n"
            b"Inactive recipients are ones that have generated"
            b' a hard bounce or a spam complaint."}',
        )
        msg = mail.EmailMessage(
            "Subject",
            "Body",
            "from@example.com",
            ["HardBounce@example.com", "Hates Spam <spam@example.com>"],
        )
        with self.assertRaises(AnymailRecipientsRefused):
            msg.send()
        status = msg.anymail_status
        self.assertEqual(status.recipients["HardBounce@example.com"].status, "rejected")
        self.assertEqual(status.recipients["spam@example.com"].status, "rejected")

    def test_recipients_invalid(self):
        self.set_mock_response(
            status_code=422,
            raw=b"""{
                "ErrorCode":300,
                "Message":"Invalid 'To' address: 'invalid@localhost'."
            }""",
        )
        msg = mail.EmailMessage(
            "Subject", "Body", "from@example.com", ["Invalid@LocalHost"]
        )
        with self.assertRaises(AnymailRecipientsRefused):
            msg.send()
        status = msg.anymail_status
        self.assertEqual(status.recipients["Invalid@LocalHost"].status, "invalid")

    def test_recipients_parse_error(self):
        self.set_mock_response(
            status_code=422,
            raw=b"""{
              "ErrorCode": 300,
              "Message": "Error parsing 'Cc': Illegal email domain '+' in address 'user@+'."
            }""",  # NOQA: E501
        )
        msg = mail.EmailMessage("Subject", "Body", "from@example.com", cc=["user@+"])
        with self.assertRaises(AnymailRecipientsRefused):
            msg.send()
        status = msg.anymail_status
        self.assertEqual(status.recipients["user@+"].status, "invalid")

    def test_from_email_invalid(self):
        # Invalid 'From' address generates same Postmark ErrorCode 300 as invalid 'To',
        # but should raise a different Anymail error
        self.set_mock_response(
            status_code=422,
            raw=b"""{
                "ErrorCode":300,
                "Message":"Invalid 'From' address: 'invalid@localhost'."
            }""",
        )
        msg = mail.EmailMessage(
            "Subject", "Body", "invalid@localhost", ["to@example.com"]
        )
        with self.assertRaises(AnymailAPIError):
            msg.send()

    def test_reply_to_invalid(self):
        # Make sure 'Reply-To' error doesn't get caught in invalid 'To' logic:
        self.set_mock_response(
            status_code=422,
            raw=b"""{
                "ErrorCode": 300,
                "Message": "Error parsing 'Reply-To': Illegal email domain '+' in address 'invalid@+'."}
            """,  # NOQA: E501
        )
        msg = mail.EmailMessage(
            "Subject",
            "Body",
            "from@example.com",
            ["to@example.com"],
            reply_to=["invalid@+"],
        )
        with self.assertRaisesMessage(AnymailAPIError, "Error parsing 'Reply-To'"):
            msg.send()

    def test_errorcode_300(self):
        # Various other problems generate same Postmark ErrorCode 300 as invalid 'To',
        # but should raise ordinary API errors
        self.set_mock_response(
            status_code=422,
            raw=b"""{
                "ErrorCode": 300,
                "Message": "Invalid metadata content. Field names are limited to 20 characters..."
            }""",  # NOQA: E501
        )
        msg = mail.EmailMessage(
            "Subject", "Body", "from@example.com", ["to@example.com"]
        )
        msg.metadata = {"this-key-name-is-too-long": "data"}
        with self.assertRaisesMessage(AnymailAPIError, "Invalid metadata content"):
            msg.send()

    def test_fail_silently(self):
        self.set_mock_response(
            status_code=422,
            raw=b'{"ErrorCode":406,'
            b'"Message":"You tried to send to a recipient'
            b" that has been marked as inactive.\\n"
            b"Found inactive addresses: hardbounce@example.com, spam@example.com.\\n"
            b"Inactive recipients are ones that have generated"
            b' a hard bounce or a spam complaint."}',
        )
        msg = mail.EmailMessage(
            "Subject",
            "Body",
            "from@example.com",
            ["HardBounce@example.com", "Hates Spam <spam@example.com>"],
        )
        msg.send(fail_silently=True)
        status = msg.anymail_status
        self.assertEqual(status.recipients["HardBounce@example.com"].status, "rejected")
        self.assertEqual(status.recipients["spam@example.com"].status, "rejected")

    @override_settings(ANYMAIL_IGNORE_RECIPIENT_STATUS=True)
    def test_ignore_recipient_status(self):
        self.set_mock_response(
            status_code=422,
            raw=b'{"ErrorCode":406,'
            b'"Message":"You tried to send to a recipient'
            b" that has been marked as inactive.\\n"
            b"Found inactive addresses: hardbounce@example.com, spam@example.com.\\n"
            b"Inactive recipients are ones that have generated"
            b' a hard bounce or a spam complaint. "}',
        )
        msg = mail.EmailMessage(
            "Subject",
            "Body",
            "from@example.com",
            ["HardBounce@example.com", "Hates Spam <spam@example.com>"],
        )
        msg.send()
        status = msg.anymail_status
        self.assertEqual(status.recipients["HardBounce@example.com"].status, "rejected")
        self.assertEqual(status.recipients["spam@example.com"].status, "rejected")

    def test_mixed_response(self):
        """If *any* recipients are valid or queued, no exception is raised"""
        self.set_mock_response(
            status_code=200,
            raw=b'{"To":"hardbounce@example.com, valid@example.com,'
            b' Hates Spam <spam@example.com>",'
            b'"SubmittedAt":"2016-03-12T22:59:06.2505871-05:00",'
            b'"MessageID":"089dce03-feee-408e-9f0c-ee69bf1c5f35",'
            b'"ErrorCode":0,'
            b'"Message":"Message OK, but will not deliver to these inactive addresses:'
            b" hardbounce@example.com, spam@example.com."
            b" Inactive recipients are ones that have generated"
            b' a hard bounce or a spam complaint."}',
        )
        msg = mail.EmailMessage(
            "Subject",
            "Body",
            "from@example.com",
            [
                "HardBounce@example.com",
                "valid@example.com",
                "Hates Spam <spam@example.com>",
            ],
        )
        sent = msg.send()
        # one message sent, successfully, to 1 of 3 recipients:
        self.assertEqual(sent, 1)
        status = msg.anymail_status
        self.assertEqual(status.recipients["HardBounce@example.com"].status, "rejected")
        self.assertEqual(status.recipients["valid@example.com"].status, "sent")
        self.assertEqual(status.recipients["spam@example.com"].status, "rejected")

    def test_delivery_delayed_response(self):
        # Postmark's "delivery may be delayed" response doesn't have an ErrorCode
        # field set to 0 (despite their API docs).
        response_data = {
            "Message": "Message accepted, but delivery may be delayed.",
            "MessageID": "38360f97-ff7f-44b2-bcd1-5ea94ff2af00",
            "SubmittedAt": "2024-08-05T02:03:37.0951168Z",
            "To": "to@example.com",
        }
        self.set_mock_response(json_data=response_data)
        sent = self.message.send()
        self.assertEqual(sent, 1)
        status = self.message.anymail_status
        self.assertEqual(status.recipients["to@example.com"].status, "queued")
        self.assertEqual(status.message_id, "38360f97-ff7f-44b2-bcd1-5ea94ff2af00")


@tag("postmark")
class PostmarkBackendSessionSharingTestCase(
    SessionSharingTestCases, PostmarkBackendMockAPITestCase
):
    """Requests session sharing tests"""

    pass  # tests are defined in SessionSharingTestCases


@tag("postmark")
@override_settings(EMAIL_BACKEND="anymail.backends.postmark.EmailBackend")
class PostmarkBackendImproperlyConfiguredTests(AnymailTestMixin, SimpleTestCase):
    """Test ESP backend without required settings in place"""

    def test_missing_api_key(self):
        with self.assertRaises(ImproperlyConfigured) as cm:
            mail.send_mail("Subject", "Message", "from@example.com", ["to@example.com"])
        errmsg = str(cm.exception)
        self.assertRegex(errmsg, r"\bPOSTMARK_SERVER_TOKEN\b")
        self.assertRegex(errmsg, r"\bANYMAIL_POSTMARK_SERVER_TOKEN\b")
