Email

from django.conf import settings
from django.db import models


class Author(models.Model):
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name


class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.PROTECT, related_name="books")

    def __str__(self):
        return self.title


class Review(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE, related_name="reviews")
    reviewer = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    body = models.TextField()
    approved = models.BooleanField(default=False)

import os

from django.core.management.utils import get_random_secret_key

SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY") or get_random_secret_key()

DEFAULT_FROM_EMAIL = '"Bookshelf" <noreply@bookshelf.example>'  # From: of ordinary messages
SERVER_EMAIL = "errors@bookshelf.example"                       # From: of mail_admins()/mail_managers()
ADMINS = ["admin@bookshelf.example"]                            # error reports and mail_admins()
MANAGERS = ["editor@bookshelf.example"]                         # mail_managers() and broken-link reports

MAILERS = {
    "default": {
        "BACKEND": "django.core.mail.backends.console.EmailBackend",
    },
}

MAILERS = {
    "default": {
        "BACKEND": "django.core.mail.backends.smtp.EmailBackend",
        "OPTIONS": {
            "host": "localhost",
        },
    },
}

import email.message

from django.core import mail
from django.core.mail import EmailMessage
from django.test import TestCase


class EmailMessageTests(TestCase):
    def test_full_message(self):
        message = EmailMessage(
            subject="Hello",
            body="Body goes here",
            from_email="from@example.com",
            to=["to1@example.com", "to2@example.com"],
            bcc=["bcc@example.com"],
            reply_to=["another@example.com"],
            headers={"X-Campaign": "autumn"},
        )
        self.assertEqual(message.send(), 1)
        self.assertEqual(
            message.recipients(),
            ["to1@example.com", "to2@example.com", "bcc@example.com"],
        )
        raw = mail.outbox[0].message()
        self.assertIsInstance(raw, email.message.EmailMessage)
        self.assertEqual(raw["Reply-To"], "another@example.com")
        self.assertNotIn("bcc@example.com", raw.as_string())

Hello {{ name }},

Your review of "{{ book.title }}" by {{ book.author }} has been approved and is now visible.

The Bookshelf team

<p>Hello {{ name }},</p>
<p>Your review of <em>{{ book.title }}</em> by {{ book.author }} has been approved and is now visible.</p>
<p>The Bookshelf team</p>

from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string


def send_review_approved(review):
    """Send the multipart 'your review was approved' message to the reviewer."""
    user = review.reviewer
    context = {"name": user.get_username(), "book": review.book}
    msg = EmailMultiAlternatives(
        subject=f"Your review of {review.book.title} is live",
        body=render_to_string("catalog/email/review_approved.txt", context),
        to=[user.email],
        reply_to=["editor@bookshelf.example"],
        headers={"List-Unsubscribe": "<mailto:unsubscribe@bookshelf.example>"},
    )
    msg.attach_alternative(
        render_to_string("catalog/email/review_approved.html", context), "text/html"
    )
    return msg.send()

from django.contrib.auth import get_user_model
from django.core import mail
from django.test import TestCase

from catalog.emails import send_review_approved
from catalog.models import Author, Book, Review


class MultipartTemplateTests(TestCase):
    def test_review_approved(self):
        author = Author.objects.create(name="Ursula K. Le Guin")
        book = Book.objects.create(title="The Dispossessed", author=author)
        user = get_user_model().objects.create_user("ana", email="ana@example.com")
        review = Review.objects.create(book=book, reviewer=user, body="Great")
        self.assertEqual(send_review_approved(review), 1)
        msg = mail.outbox[0]
        self.assertEqual(msg.to, ["ana@example.com"])
        self.assertEqual(
            msg.extra_headers["List-Unsubscribe"],
            "<mailto:unsubscribe@bookshelf.example>",
        )
        self.assertEqual(len(msg.alternatives), 1)
        self.assertEqual(msg.alternatives[0].mimetype, "text/html")
        self.assertIs(msg.body_contains("The Dispossessed"), True)
        self.assertIs(msg.body_contains("<em>"), False)

from pathlib import Path
from tempfile import TemporaryDirectory

from django.core import mail
from django.core.mail import EmailMessage
from django.test import TestCase


class AttachmentTests(TestCase):
    def test_attachments(self):
        msg = EmailMessage("Report", "See attached", "from@example.com", ["to@example.com"])
        msg.attach("report.csv", "title,price\nDune,9.99\n", "text/csv")
        with TemporaryDirectory() as tmp:
            path = Path(tmp) / "cover.png"
            path.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 16)
            msg.attach_file(path)
        msg.send()
        sent = mail.outbox[0]
        self.assertEqual([a.filename for a in sent.attachments], ["report.csv", "cover.png"])
        self.assertEqual(sent.attachments[1].mimetype, "image/png")

import email.utils
from email.message import MIMEPart

from django.core import mail
from django.core.mail import EmailMultiAlternatives
from django.test import TestCase


class InlineImageTests(TestCase):
    def test_inline_image_with_mimepart(self):
        msg = EmailMultiAlternatives("Logo", "text", "from@example.com", ["to@example.com"])
        cid = email.utils.make_msgid()                 # random Content-ID, with angle brackets
        inline = MIMEPart()
        inline.set_content(
            b"\x89PNG\r\n\x1a\n" + b"\x00" * 16,       # real code: the image bytes
            maintype="image", subtype="png", disposition="inline", cid=cid,
        )
        msg.attach(inline)
        msg.attach_alternative(f'<img src="cid:{cid[1:-1]}">', "text/html")  # no angle brackets in cid:
        msg.send()
        raw = mail.outbox[0].message().as_string()
        self.assertIn("Content-ID: " + cid, raw)
        self.assertIn("Content-Disposition: inline", raw)

import email.policy

from django.core.mail import EmailMessage
from django.test import SimpleTestCase


class PolicyTests(SimpleTestCase):
    def test_message_policy(self):
        msg = EmailMessage("Hi", "line one\nline two", "f@example.com", ["t@example.com"])
        self.assertIn(b"line one\r\nline two", msg.message(policy=email.policy.SMTP).as_bytes())
        self.assertIn(b"line one\nline two", msg.message().as_bytes())

from email.headerregistry import Address

from django.core import mail
from django.core.mail import EmailMessage, send_mail
from django.test import TestCase


class SecurityTests(TestCase):
    def test_header_injection_raises_value_error(self):
        msg = EmailMessage(
            "Hello\r\nBcc: victim@example.com", "x", "from@example.com", ["to@example.com"]
        )
        with self.assertRaises(ValueError):
            msg.message()

    def test_address_object_is_safe(self):
        evil = 'Bob" <attacker@evil.example>, "x'
        address = Address(display_name=evil, addr_spec="bob@example.com")
        send_mail("Hi", "Body", None, [address])
        header = mail.outbox[0].message()["To"]
        self.assertEqual(len(header.addresses), 1)
        self.assertEqual(header.addresses[0].addr_spec, "bob@example.com")

from django.contrib.admin.views.decorators import staff_member_required
from django.db import transaction
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.views.decorators.http import require_POST

from .emails import send_review_approved
from .models import Review


@staff_member_required
@require_POST
def approve_review(request, pk):
    review = get_object_or_404(Review, pk=pk)
    review.approved = True
    review.save(update_fields=["approved"])
    # Send only if the transaction that approved the review is really committed.
    transaction.on_commit(lambda: send_review_approved(review))
    return HttpResponse("approved", status=202)

from django.urls import path

from . import views

app_name = "catalog"
urlpatterns = [
    path("reviews/<int:pk>/approve/", views.approve_review, name="approve-review"),
]

J=cookies.txt
curl -s -c $J -b $J http://127.0.0.1:46101/admin/login/ -o /dev/null
T=$(grep csrftoken $J | awk '{print $7}')
curl -s -c $J -b $J -o /dev/null -w 'login %{http_code}\n' \
  -d "username=eve&password=$PW&csrfmiddlewaretoken=$T&next=/admin/" \
  -H "Referer: http://127.0.0.1:46101/admin/login/" http://127.0.0.1:46101/admin/login/
T=$(grep csrftoken $J | awk '{print $7}')
curl -s -i -b $J -c $J -X POST -H "X-CSRFToken: $T" -H "Referer: http://127.0.0.1:46101/" \
  http://127.0.0.1:46101/reviews/1/approve/ | sed -n '1p;$p'
curl -s -o /dev/null -w 'GET -> %{http_code}\n' -b $J http://127.0.0.1:46101/reviews/1/approve/

login 302
HTTP/1.1 202 Accepted
approved
GET -> 405

MIME-Version: 1.0
Content-Type: multipart/alternative;
 boundary="===============0844861002314230432=="
Subject: Your review of The Dispossessed is live
From: "Bookshelf" <noreply@bookshelf.example>
To: ana@example.com
Reply-To: editor@bookshelf.example
Date: Sat, 03 Oct 2026 00:50:42 +0000
Message-ID: <…>
List-Unsubscribe: <mailto:unsubscribe@bookshelf.example>

--===============0844861002314230432==
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: quoted-printable

Hello ana,
…

from django.contrib.auth import get_user_model
from django.core import mail
from django.test import TestCase

from catalog.models import Author, Book, Review


class ApproveViewTests(TestCase):
    def test_approve_sends_email_after_commit(self):
        author = Author.objects.create(name="Ursula K. Le Guin")
        book = Book.objects.create(title="The Dispossessed", author=author)
        reader = get_user_model().objects.create_user("ana", email="ana@example.com")
        staff = get_user_model().objects.create_user("eve", is_staff=True)
        review = Review.objects.create(book=book, reviewer=reader, body="Great")
        self.client.force_login(staff)
        with self.captureOnCommitCallbacks(execute=True) as callbacks:
            response = self.client.post(f"/reviews/{review.pk}/approve/")
        self.assertEqual(response.status_code, 202)
        self.assertEqual(len(callbacks), 1)
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].to, ["ana@example.com"])
        self.assertEqual(self.client.get(f"/reviews/{review.pk}/approve/").status_code, 405)

import os

MAILERS = {
    "default": {
        "BACKEND": "django.core.mail.backends.smtp.EmailBackend",
        "OPTIONS": {
            "host": "smtp.example.net",
            "use_tls": True,
            "username": os.environ["EMAIL_ACCOUNT_ID"],
            "password": os.environ["EMAIL_API_KEY"],
        },
    },
    "notifications": {
        "BACKEND": "example.third.party.EmailBackend",
        "OPTIONS": {
            "api_key": os.environ["THIRD_PARTY_API_KEY"],
            "region": "eu",
        },
    },
    "admin": {
        "BACKEND": "django.core.mail.backends.smtp.EmailBackend",
        "OPTIONS": {"host": "localhost"},
    },
}

from django.core import mail
from django.core.mail import EmailMessage, send_mail
from django.test import TestCase, override_settings

MAILERS = {
    "default": {"BACKEND": "django.core.mail.backends.locmem.EmailBackend"},
    "notifications": {"BACKEND": "django.core.mail.backends.locmem.EmailBackend"},
}


class UsingTests(TestCase):
    @override_settings(MAILERS=MAILERS)
    def test_using_selects_alias(self):
        send_mail("A", "a", "from@example.com", ["to@example.com"])
        send_mail("B", "b", "from@example.com", ["to@example.com"], using="notifications")
        EmailMessage("C", "c", "from@example.com", ["to@example.com"]).send(using="notifications")
        self.assertEqual(
            [m.sent_using for m in mail.outbox], ["default", "notifications", "notifications"]
        )

from django.core import mail
from django.core.mail import EmailMessage
from django.test import TestCase, override_settings

MAILERS = {
    "default": {"BACKEND": "django.core.mail.backends.locmem.EmailBackend"},
    "notifications": {"BACKEND": "django.core.mail.backends.locmem.EmailBackend"},
}


class ManyMessagesTests(TestCase):
    @override_settings(MAILERS=MAILERS)
    def test_send_messages_with_context_manager(self):
        emails = [EmailMessage("Hi", "x", None, [f"u{i}@example.com"]) for i in range(3)]
        with mail.mailers["notifications"] as backend:
            self.assertEqual(backend.send_messages(emails), 3)
        self.assertEqual(len(mail.outbox), 3)
        self.assertEqual(mail.mailers.default.alias, "default")

ERRORS:
?: (mail.E001) Your MAILERS setting uses a development-only email backend in the 'default' entry (django.core.mail.backends.console.EmailBackend).
	HINT: Use a production-ready email backend, such as the SMTP backend, otherwise email will not be sent.

from .settings import *  # noqa: F403

INSTALLED_APPS = [*INSTALLED_APPS, "anymail"]  # noqa: F405
MAILERS = {
    "default": {"BACKEND": "django.core.mail.backends.console.EmailBackend"},
    # In production: "anymail.backends.<esp>.EmailBackend" plus the provider's OPTIONS.
    # The test backend ships with Anymail, accepts every Anymail extension and sends nothing.
    "transactional": {"BACKEND": "anymail.backends.test.EmailBackend"},
}

from anymail.message import AnymailMessage
from django.core import mail

msg = AnymailMessage(subject="Order shipped", body="On its way", to=["ana@example.com"])
msg.tags = ["shipping"]
msg.metadata = {"order_id": 42}
msg.track_clicks = True
print(msg.send(using="transactional"))
sent = mail.outbox[0]
print(sent.tags, sent.metadata, sent.anymail_status.status)

1
['shipping'] {'order_id': 42} {'sent'}

import os

EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
EMAIL_HOST = "mail.example.net"
EMAIL_USE_TLS = True
EMAIL_PORT = 587
EMAIL_HOST_USER = "user@example.net"
EMAIL_HOST_PASSWORD = os.environ["EMAIL_PASSWORD"]

import os

MAILERS = {
    "default": {
        "BACKEND": "django.core.mail.backends.smtp.EmailBackend",
        "OPTIONS": {
            "host": "mail.example.net",
            "use_tls": True,
            # port is not needed: it defaults to 587 with use_tls True.
            "username": "user@example.net",
            "password": os.environ["EMAIL_PASSWORD"],
        },
    },
}

from django.core import mail
from django.core.mail import send_mail
from django.test import TestCase, override_settings


class FailSilentlyReplacementTests(TestCase):
    def test_fail_silently_replacement(self):
        def notify():
            try:
                send_mail("A", "a", "f@example.com", ["t@example.com"])
            except mail.MailerDoesNotExist:
                return 0
            return 1

        with override_settings(MAILERS={}):
            self.assertEqual(notify(), 0)
        self.assertEqual(notify(), 1)

AttributeError: The EMAIL_HOST setting is not available when MAILERS is defined.
RuntimeError: get_connection(backend, ...) is not supported with MAILERS.

from django.core import mail
from django.core.mail import send_mail
from django.test import TestCase


class EmailTest(TestCase):
    def test_send_email(self):
        sent = send_mail(
            "Subject here",
            "Here is the message.",
            "from@example.com",
            ["to@example.com"],
        )
        self.assertEqual(sent, 1)
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].subject, "Subject here")
        self.assertEqual(mail.outbox[0].sent_using, "default")  # 6.1: which mailer sent it