Fixed #14440 - Converted mail doctests to unittests.

Thanks to Rob Hudson for the patch and also to andialbrecht who filed a
similar patch that I didn't use.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@14143 bcc190cf-cafb-0310-a4f2-bffc1f526a37
This commit is contained in:
Jacob Kaplan-Moss 2010-10-11 15:11:55 +00:00
parent e0ec458360
commit e01bce1bfb
1 changed files with 307 additions and 408 deletions

View File

@ -1,446 +1,345 @@
# coding: utf-8 # coding: utf-8
import email
import os
import shutil
import sys
import tempfile
from StringIO import StringIO
from django.conf import settings
from django.core import mail
from django.core.mail import EmailMessage, mail_admins, mail_managers, EmailMultiAlternatives
from django.core.mail import send_mail, send_mass_mail
from django.core.mail.backends.base import BaseEmailBackend
from django.core.mail.backends import console, dummy, locmem, filebased, smtp
from django.core.mail.message import BadHeaderError
from django.test import TestCase
from django.utils.translation import ugettext_lazy
r""" class MailTests(TestCase):
# Tests for the django.core.mail.
>>> import os def test_ascii(self):
>>> import shutil email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'])
>>> import tempfile message = email.message()
>>> from StringIO import StringIO self.assertEqual(message['Subject'].encode(), 'Subject')
>>> from django.conf import settings self.assertEqual(message.get_payload(), 'Content')
>>> from django.core import mail self.assertEqual(message['From'], 'from@example.com')
>>> from django.core.mail import EmailMessage, mail_admins, mail_managers, EmailMultiAlternatives self.assertEqual(message['To'], 'to@example.com')
>>> from django.core.mail import send_mail, send_mass_mail
>>> from django.core.mail.backends.base import BaseEmailBackend
>>> from django.core.mail.backends import console, dummy, locmem, filebased, smtp
>>> from django.utils.translation import ugettext_lazy
# Test normal ascii character case: def test_multiple_recipients(self):
email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com','other@example.com'])
message = email.message()
self.assertEqual(message['Subject'].encode(), 'Subject')
self.assertEqual(message.get_payload(), 'Content')
self.assertEqual(message['From'], 'from@example.com')
self.assertEqual(message['To'], 'to@example.com, other@example.com')
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com']) def test_cc(self):
>>> message = email.message() """Regression test for #7722"""
>>> message['Subject'].encode() email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'], cc=['cc@example.com'])
'Subject' message = email.message()
>>> message.get_payload() self.assertEqual(message['Cc'], 'cc@example.com')
'Content' self.assertEqual(email.recipients(), ['to@example.com', 'cc@example.com'])
>>> message['From']
'from@example.com'
>>> message['To']
'to@example.com'
# Test multiple-recipient case # Verify headers
old_stdout = sys.stdout
sys.stdout = StringIO()
connection = console.EmailBackend()
connection.send_messages([email])
self.assertTrue(sys.stdout.getvalue().startswith('Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nCc: cc@example.com\nDate: '))
sys.stdout = old_stdout
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com','other@example.com']) # Test multiple CC with multiple To
>>> message = email.message() email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com', 'other@example.com'], cc=['cc@example.com', 'cc.other@example.com'])
>>> message['Subject'].encode() message = email.message()
'Subject' self.assertEqual(message['Cc'], 'cc@example.com, cc.other@example.com')
>>> message.get_payload() self.assertEqual(email.recipients(), ['to@example.com', 'other@example.com', 'cc@example.com', 'cc.other@example.com'])
'Content'
>>> message['From']
'from@example.com'
>>> message['To']
'to@example.com, other@example.com'
# Test for header injection # Testing with Bcc
email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com', 'other@example.com'], cc=['cc@example.com', 'cc.other@example.com'], bcc=['bcc@example.com'])
message = email.message()
self.assertEqual(message['Cc'], 'cc@example.com, cc.other@example.com')
self.assertEqual(email.recipients(), ['to@example.com', 'other@example.com', 'cc@example.com', 'cc.other@example.com', 'bcc@example.com'])
>>> email = EmailMessage('Subject\nInjection Test', 'Content', 'from@example.com', ['to@example.com']) def test_header_injection(self):
>>> message = email.message() email = EmailMessage('Subject\nInjection Test', 'Content', 'from@example.com', ['to@example.com'])
Traceback (most recent call last): self.assertRaises(BadHeaderError, email.message)
... email = EmailMessage(ugettext_lazy('Subject\nInjection Test'), 'Content', 'from@example.com', ['to@example.com'])
BadHeaderError: Header values can't contain newlines (got u'Subject\nInjection Test' for header 'Subject') self.assertRaises(BadHeaderError, email.message)
>>> email = EmailMessage(ugettext_lazy('Subject\nInjection Test'), 'Content', 'from@example.com', ['to@example.com']) def test_space_continuation(self):
>>> message = email.message() """
Traceback (most recent call last): Test for space continuation character in long (ascii) subject headers (#7747)
... """
BadHeaderError: Header values can't contain newlines (got u'Subject\nInjection Test' for header 'Subject') email = EmailMessage('Long subject lines that get wrapped should use a space continuation character to get expected behaviour in Outlook and Thunderbird', 'Content', 'from@example.com', ['to@example.com'])
message = email.message()
self.assertEqual(message['Subject'], 'Long subject lines that get wrapped should use a space continuation\n character to get expected behaviour in Outlook and Thunderbird')
# Test for space continuation character in long (ascii) subject headers (#7747) def test_message_header_overrides(self):
"""
Specifying dates or message-ids in the extra headers overrides the
default values (#9233)
"""
headers = {"date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
email = EmailMessage('subject', 'content', 'from@example.com', ['to@example.com'], headers=headers)
self.assertEqual(email.message().as_string(), 'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: subject\nFrom: from@example.com\nTo: to@example.com\ndate: Fri, 09 Nov 2001 01:08:47 -0000\nMessage-ID: foo\n\ncontent')
>>> email = EmailMessage('Long subject lines that get wrapped should use a space continuation character to get expected behaviour in Outlook and Thunderbird', 'Content', 'from@example.com', ['to@example.com']) def test_empty_admins(self):
>>> message = email.message() """
>>> message.as_string() Test that mail_admins/mail_managers doesn't connect to the mail server
'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Long subject lines that get wrapped should use a space continuation\n character to get expected behaviour in Outlook and Thunderbird\nFrom: from@example.com\nTo: to@example.com\nDate: ...\nMessage-ID: <...>\n\nContent' if there are no recipients (#9383)
"""
old_admins = settings.ADMINS
old_managers = settings.MANAGERS
# Specifying dates or message-ids in the extra headers overrides the defaul settings.ADMINS = settings.MANAGERS = [('nobody','nobody@example.com')]
# values (#9233). mail.outbox = []
mail_admins('hi', 'there')
self.assertEqual(len(mail.outbox), 1)
mail.outbox = []
mail_managers('hi', 'there')
self.assertEqual(len(mail.outbox), 1)
>>> headers = {"date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"} settings.ADMINS = settings.MANAGERS = []
>>> email = EmailMessage('subject', 'content', 'from@example.com', ['to@example.com'], headers=headers) mail.outbox = []
>>> email.message().as_string() mail_admins('hi', 'there')
'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: subject\nFrom: from@example.com\nTo: to@example.com\ndate: Fri, 09 Nov 2001 01:08:47 -0000\nMessage-ID: foo\n\ncontent' self.assertEqual(len(mail.outbox), 0)
mail.outbox = []
mail_managers('hi', 'there')
self.assertEqual(len(mail.outbox), 0)
# Test that mail_admins/mail_managers doesn't connect to the mail server if there are no recipients (#9383) settings.ADMINS = old_admins
settings.MANAGERS = old_managers
>>> old_admins = settings.ADMINS def test_from_header(self):
>>> old_managers = settings.MANAGERS """
>>> settings.ADMINS = [] Make sure we can manually set the From header (#9214)
>>> settings.MANAGERS = [] """
>>> mail.outbox = [] email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> mail_admins('hi','there') message = email.message()
>>> len(mail.outbox) self.assertEqual(message['From'], 'from@example.com')
0
>>> mail.outbox = []
>>> mail_managers('hi','there')
>>> len(mail.outbox)
0
>>> settings.ADMINS = settings.MANAGERS = [('nobody','nobody@example.com')]
>>> mail.outbox = []
>>> mail_admins('hi','there')
>>> len(mail.outbox)
1
>>> mail.outbox = []
>>> mail_managers('hi','there')
>>> len(mail.outbox)
1
# Make sure we can manually set the From header (#9214) def test_multiple_message_call(self):
"""
Regression for #13259 - Make sure that headers are not changed when
calling EmailMessage.message()
"""
email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
message = email.message()
self.assertEqual(message['From'], 'from@example.com')
message = email.message()
self.assertEqual(message['From'], 'from@example.com')
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'}) def test_unicode_header(self):
>>> message = email.message() """
>>> message['From'] Regression for #11144 - When a to/from/cc header contains unicode,
'from@example.com' make sure the email addresses are parsed correctly (especially with
regards to commas)
"""
email = EmailMessage('Subject', 'Content', 'from@example.com', ['"Firstname Sürname" <to@example.com>','other@example.com'])
self.assertEqual(email.message()['To'], '=?utf-8?q?Firstname_S=C3=BCrname?= <to@example.com>, other@example.com')
email = EmailMessage('Subject', 'Content', 'from@example.com', ['"Sürname, Firstname" <to@example.com>','other@example.com'])
self.assertEqual(email.message()['To'], '=?utf-8?q?S=C3=BCrname=2C_Firstname?= <to@example.com>, other@example.com')
# Regression for #13259 - Make sure that headers are not changed def test_safe_mime_multipart(self):
# when calling EmailMessage.message() """
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'}) Make sure headers can be set with a different encoding than utf-8 in
>>> message = email.message() SafeMIMEMultipart as well
>>> message['From'] """
'from@example.com' headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
>>> message = email.message() subject, from_email, to = 'hello', 'from@example.com', '"Sürname, Firstname" <to@example.com>'
>>> message['From'] text_content = 'This is an important message.'
'from@example.com' html_content = '<p>This is an <strong>important</strong> message.</p>'
msg = EmailMultiAlternatives('Message from Firstname Sürname', text_content, from_email, [to], headers=headers)
msg.attach_alternative(html_content, "text/html")
msg.encoding = 'iso-8859-1'
self.assertEqual(msg.message()['To'], '=?iso-8859-1?q?S=FCrname=2C_Firstname?= <to@example.com>')
self.assertEqual(msg.message()['Subject'].encode(), u'=?iso-8859-1?q?Message_from_Firstname_S=FCrname?=')
# Regression for #11144 - When a to/from/cc header contains unicode, def test_encoding(self):
# make sure the email addresses are parsed correctly (especially """
# with regards to commas) Regression for #12791 - Encode body correctly with other encodings
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['"Firstname Sürname" <to@example.com>','other@example.com']) than utf-8
>>> email.message()['To'] """
'=?utf-8?q?Firstname_S=C3=BCrname?= <to@example.com>, other@example.com' email = EmailMessage('Subject', 'Firstname Sürname is a great guy.', 'from@example.com', ['other@example.com'])
email.encoding = 'iso-8859-1'
message = email.message()
self.assertTrue(message.as_string().startswith('Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: other@example.com'))
self.assertEqual(message.get_payload(), 'Firstname S=FCrname is a great guy.')
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['"Sürname, Firstname" <to@example.com>','other@example.com']) # Make sure MIME attachments also works correctly with other encodings than utf-8
>>> email.message()['To'] text_content = 'Firstname Sürname is a great guy.'
'=?utf-8?q?S=C3=BCrname=2C_Firstname?= <to@example.com>, other@example.com' html_content = '<p>Firstname Sürname is a <strong>great</strong> guy.</p>'
msg = EmailMultiAlternatives('Subject', text_content, 'from@example.com', ['to@example.com'])
msg.encoding = 'iso-8859-1'
msg.attach_alternative(html_content, "text/html")
self.assertEqual(msg.message().get_payload(0).as_string(), 'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\nFirstname S=FCrname is a great guy.')
self.assertEqual(msg.message().get_payload(1).as_string(), 'Content-Type: text/html; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>')
# Regression for #6918 - When a header contains unicode, def test_attachments(self):
# make sure headers can be set with a different encoding than utf-8 """Regression test for #9367"""
>>> email = EmailMessage('Message from Firstname Sürname', 'Content', 'from@example.com', ['"Sürname, Firstname" <to@example.com>','other@example.com']) headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
>>> email.encoding = 'iso-8859-1' subject, from_email, to = 'hello', 'from@example.com', 'to@example.com'
>>> email.message()['To'] text_content = 'This is an important message.'
'=?iso-8859-1?q?S=FCrname=2C_Firstname?= <to@example.com>, other@example.com' html_content = '<p>This is an <strong>important</strong> message.</p>'
>>> email.message()['Subject'].encode() msg = EmailMultiAlternatives(subject, text_content, from_email, [to], headers=headers)
u'=?iso-8859-1?q?Message_from_Firstname_S=FCrname?=' msg.attach_alternative(html_content, "text/html")
msg.attach("an attachment.pdf", "%PDF-1.4.%...", mimetype="application/pdf")
msg_str = msg.message().as_string()
message = email.message_from_string(msg_str)
self.assertTrue(message.is_multipart())
self.assertEqual(message.get_content_type(), 'multipart/mixed')
self.assertEqual(message.get_default_type(), 'text/plain')
payload = message.get_payload()
self.assertEqual(payload[0].get_content_type(), 'multipart/alternative')
self.assertEqual(payload[1].get_content_type(), 'application/pdf')
# Make sure headers can be set with a different encoding than utf-8 in SafeMIMEMultipart as well def test_arbitrary_stream(self):
>>> headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"} """
>>> subject, from_email, to = 'hello', 'from@example.com', '"Sürname, Firstname" <to@example.com>' Test that the console backend can be pointed at an arbitrary stream.
>>> text_content = 'This is an important message.' """
>>> html_content = '<p>This is an <strong>important</strong> message.</p>' s = StringIO()
>>> msg = EmailMultiAlternatives('Message from Firstname Sürname', text_content, from_email, [to], headers=headers) connection = mail.get_connection('django.core.mail.backends.console.EmailBackend', stream=s)
>>> msg.attach_alternative(html_content, "text/html") send_mail('Subject', 'Content', 'from@example.com', ['to@example.com'], connection=connection)
>>> msg.encoding = 'iso-8859-1' self.assertTrue(s.getvalue().startswith('Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nDate: '))
>>> msg.message()['To']
'=?iso-8859-1?q?S=FCrname=2C_Firstname?= <to@example.com>'
>>> msg.message()['Subject'].encode()
u'=?iso-8859-1?q?Message_from_Firstname_S=FCrname?='
# Regression for #12791 - Encode body correctly with other encodings than utf-8 def test_stdout(self):
>>> email = EmailMessage('Subject', 'Firstname Sürname is a great guy.', 'from@example.com', ['other@example.com']) """Make sure that the console backend writes to stdout by default"""
>>> email.encoding = 'iso-8859-1' old_stdout = sys.stdout
>>> message = email.message() sys.stdout = StringIO()
>>> message.as_string() connection = console.EmailBackend()
'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: other@example.com\nDate: ...\nMessage-ID: <...>\n\nFirstname S=FCrname is a great guy.' email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
connection.send_messages([email])
self.assertTrue(sys.stdout.getvalue().startswith('Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nDate: '))
sys.stdout = old_stdout
# Make sure MIME attachments also works correctly with other encodings than utf-8 def test_dummy(self):
>>> text_content = 'Firstname Sürname is a great guy.' """
>>> html_content = '<p>Firstname Sürname is a <strong>great</strong> guy.</p>' Make sure that dummy backends returns correct number of sent messages
>>> msg = EmailMultiAlternatives('Subject', text_content, 'from@example.com', ['to@example.com']) """
>>> msg.encoding = 'iso-8859-1' connection = dummy.EmailBackend()
>>> msg.attach_alternative(html_content, "text/html") email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> msg.message().get_payload(0).as_string() self.assertEqual(connection.send_messages([email, email, email]), 3)
'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\nFirstname S=FCrname is a great guy.'
>>> msg.message().get_payload(1).as_string()
'Content-Type: text/html; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>'
# Handle attachments within an multipart/alternative mail correctly (#9367) def test_locmem(self):
# (test is not as precise/clear as it could be w.r.t. email tree structure, """
# but it's good enough.) Make sure that the locmen backend populates the outbox.
>>> headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"} """
>>> subject, from_email, to = 'hello', 'from@example.com', 'to@example.com' mail.outbox = []
>>> text_content = 'This is an important message.' connection = locmem.EmailBackend()
>>> html_content = '<p>This is an <strong>important</strong> message.</p>' email1 = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> msg = EmailMultiAlternatives(subject, text_content, from_email, [to], headers=headers) email2 = EmailMessage('Subject 2', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> msg.attach_alternative(html_content, "text/html") connection.send_messages([email1, email2])
>>> msg.attach("an attachment.pdf", "%PDF-1.4.%...", mimetype="application/pdf") self.assertEqual(len(mail.outbox), 2)
>>> print msg.message().as_string() self.assertEqual(mail.outbox[0].subject, 'Subject')
Content-Type: multipart/mixed; boundary="..." self.assertEqual(mail.outbox[1].subject, 'Subject 2')
MIME-Version: 1.0
Subject: hello
From: from@example.com
To: to@example.com
Date: Fri, 09 Nov 2001 01:08:47 -0000
Message-ID: foo
...
Content-Type: multipart/alternative;...
...
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
...
This is an important message.
...
Content-Type: text/html; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
...
<p>This is an <strong>important</strong> message.</p>
...
...
Content-Type: application/pdf
MIME-Version: 1.0
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="an attachment.pdf"
...
JVBERi0xLjQuJS4uLg==
...
# Make sure that the console backend writes to stdout by default # Make sure that multiple locmem connections share mail.outbox
>>> connection = console.EmailBackend() mail.outbox = []
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'}) connection2 = locmem.EmailBackend()
>>> connection.send_messages([email]) email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
Content-Type: text/plain; charset="utf-8" connection.send_messages([email])
MIME-Version: 1.0 connection2.send_messages([email])
Content-Transfer-Encoding: quoted-printable self.assertEqual(len(mail.outbox), 2)
Subject: Subject
From: from@example.com
To: to@example.com
Date: ...
Message-ID: ...
Content def test_file_backend(self):
------------------------------------------------------------------------------- tmp_dir = tempfile.mkdtemp()
1 connection = filebased.EmailBackend(file_path=tmp_dir)
email1 = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
connection.send_messages([email1])
self.assertEqual(len(os.listdir(tmp_dir)), 1)
message = email.message_from_file(open(os.path.join(tmp_dir, os.listdir(tmp_dir)[0])))
self.assertEqual(message.get_content_type(), 'text/plain')
self.assertEqual(message.get('subject'), 'Subject')
self.assertEqual(message.get('from'), 'from@example.com')
self.assertEqual(message.get('to'), 'to@example.com')
connection2 = filebased.EmailBackend(file_path=tmp_dir)
connection2.send_messages([email1])
self.assertEqual(len(os.listdir(tmp_dir)), 2)
connection.send_messages([email1])
self.assertEqual(len(os.listdir(tmp_dir)), 2)
email1.connection = filebased.EmailBackend(file_path=tmp_dir)
connection_created = connection.open()
email1.send()
self.assertEqual(len(os.listdir(tmp_dir)), 3)
email1.send()
self.assertEqual(len(os.listdir(tmp_dir)), 3)
connection.close()
shutil.rmtree(tmp_dir)
# Test that the console backend can be pointed at an arbitrary stream def test_arbitrary_keyword(self):
>>> s = StringIO() """
>>> connection = mail.get_connection('django.core.mail.backends.console.EmailBackend', stream=s) Make sure that get_connection() accepts arbitrary keyword that might be
>>> send_mail('Subject', 'Content', 'from@example.com', ['to@example.com'], connection=connection) used with custom backends.
1 """
>>> print s.getvalue() c = mail.get_connection(fail_silently=True, foo='bar')
Content-Type: text/plain; charset="utf-8" self.assertTrue(c.fail_silently)
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Subject: Subject
From: from@example.com
To: to@example.com
Date: ...
Message-ID: ...
Content def test_custom_backend(self):
------------------------------------------------------------------------------- """Test custom backend defined in this suite."""
conn = mail.get_connection('regressiontests.mail.custombackend.EmailBackend')
self.assertTrue(hasattr(conn, 'test_outbox'))
email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
conn.send_messages([email])
self.assertEqual(len(conn.test_outbox), 1)
# Make sure that dummy backends returns correct number of sent messages def test_backend_arg(self):
>>> connection = dummy.EmailBackend() """Test backend argument of mail.get_connection()"""
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'}) self.assertTrue(isinstance(mail.get_connection('django.core.mail.backends.smtp.EmailBackend'), smtp.EmailBackend))
>>> connection.send_messages([email, email, email]) self.assertTrue(isinstance(mail.get_connection('django.core.mail.backends.locmem.EmailBackend'), locmem.EmailBackend))
3 self.assertTrue(isinstance(mail.get_connection('django.core.mail.backends.dummy.EmailBackend'), dummy.EmailBackend))
self.assertTrue(isinstance(mail.get_connection('django.core.mail.backends.console.EmailBackend'), console.EmailBackend))
tmp_dir = tempfile.mkdtemp()
self.assertTrue(isinstance(mail.get_connection('django.core.mail.backends.filebased.EmailBackend', file_path=tmp_dir), filebased.EmailBackend))
shutil.rmtree(tmp_dir)
self.assertTrue(isinstance(mail.get_connection(), locmem.EmailBackend))
# Make sure that locmen backend populates the outbox def test_connection_arg(self):
>>> mail.outbox = [] """Test connection argument to send_mail(), et. al."""
>>> connection = locmem.EmailBackend() connection = mail.get_connection('django.core.mail.backends.locmem.EmailBackend')
>>> email1 = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> email2 = EmailMessage('Subject 2', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> connection.send_messages([email1, email2])
2
>>> len(mail.outbox)
2
>>> mail.outbox[0].subject
'Subject'
>>> mail.outbox[1].subject
'Subject 2'
# Make sure that multiple locmem connections share mail.outbox mail.outbox = []
>>> mail.outbox = [] send_mail('Subject', 'Content', 'from@example.com', ['to@example.com'], connection=connection)
>>> connection1 = locmem.EmailBackend() self.assertEqual(len(mail.outbox), 1)
>>> connection2 = locmem.EmailBackend() message = mail.outbox[0]
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'}) self.assertEqual(message.subject, 'Subject')
>>> connection1.send_messages([email]) self.assertEqual(message.from_email, 'from@example.com')
1 self.assertEqual(message.to, ['to@example.com'])
>>> connection2.send_messages([email])
1
>>> len(mail.outbox)
2
# Make sure that the file backend write to the right location mail.outbox = []
>>> tmp_dir = tempfile.mkdtemp() send_mass_mail([
>>> connection = filebased.EmailBackend(file_path=tmp_dir) ('Subject1', 'Content1', 'from1@example.com', ['to1@example.com']),
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'}) ('Subject2', 'Content2', 'from2@example.com', ['to2@example.com'])
>>> connection.send_messages([email]) ], connection=connection)
1 self.assertEqual(len(mail.outbox), 2)
>>> len(os.listdir(tmp_dir)) message = mail.outbox[0]
1 self.assertEqual(message.subject, 'Subject1')
>>> print open(os.path.join(tmp_dir, os.listdir(tmp_dir)[0])).read() self.assertEqual(message.from_email, 'from1@example.com')
Content-Type: text/plain; charset="utf-8" self.assertEqual(message.to, ['to1@example.com'])
MIME-Version: 1.0 message = mail.outbox[1]
Content-Transfer-Encoding: quoted-printable self.assertEqual(message.subject, 'Subject2')
Subject: Subject self.assertEqual(message.from_email, 'from2@example.com')
From: from@example.com self.assertEqual(message.to, ['to2@example.com'])
To: to@example.com
Date: ...
Message-ID: ...
Content old_admins = settings.ADMINS
------------------------------------------------------------------------------- old_managers = settings.MANAGERS
settings.ADMINS = settings.MANAGERS = [('nobody','nobody@example.com')]
>>> connection2 = filebased.EmailBackend(file_path=tmp_dir) mail.outbox = []
>>> connection2.send_messages([email]) mail_admins('Subject', 'Content', connection=connection)
1 self.assertEqual(len(mail.outbox), 1)
>>> len(os.listdir(tmp_dir)) message = mail.outbox[0]
2 self.assertEqual(message.subject, '[Django] Subject')
>>> connection.send_messages([email]) self.assertEqual(message.from_email, 'root@localhost')
1 self.assertEqual(message.to, ['nobody@example.com'])
>>> len(os.listdir(tmp_dir))
2
>>> email.connection = filebased.EmailBackend(file_path=tmp_dir)
>>> connection_created = connection.open()
>>> num_sent = email.send()
>>> len(os.listdir(tmp_dir))
3
>>> num_sent = email.send()
>>> len(os.listdir(tmp_dir))
3
>>> connection.close()
>>> shutil.rmtree(tmp_dir)
# Make sure that get_connection() accepts arbitrary keyword that might be mail.outbox = []
# used with custom backends. mail_managers('Subject', 'Content', connection=connection)
>>> c = mail.get_connection(fail_silently=True, foo='bar') self.assertEqual(len(mail.outbox), 1)
>>> c.fail_silently message = mail.outbox[0]
True self.assertEqual(message.subject, '[Django] Subject')
self.assertEqual(message.from_email, 'root@localhost')
self.assertEqual(message.to, ['nobody@example.com'])
# Test custom backend defined in this suite. settings.ADMINS = old_admins
>>> conn = mail.get_connection('regressiontests.mail.custombackend.EmailBackend') settings.MANAGERS = old_managers
>>> hasattr(conn, 'test_outbox')
True
>>> email = EmailMessage('Subject', 'Content', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
>>> conn.send_messages([email])
1
>>> len(conn.test_outbox)
1
# Test backend argument of mail.get_connection()
>>> isinstance(mail.get_connection('django.core.mail.backends.smtp.EmailBackend'), smtp.EmailBackend)
True
>>> isinstance(mail.get_connection('django.core.mail.backends.locmem.EmailBackend'), locmem.EmailBackend)
True
>>> isinstance(mail.get_connection('django.core.mail.backends.dummy.EmailBackend'), dummy.EmailBackend)
True
>>> isinstance(mail.get_connection('django.core.mail.backends.console.EmailBackend'), console.EmailBackend)
True
>>> tmp_dir = tempfile.mkdtemp()
>>> isinstance(mail.get_connection('django.core.mail.backends.filebased.EmailBackend', file_path=tmp_dir), filebased.EmailBackend)
True
>>> shutil.rmtree(tmp_dir)
>>> isinstance(mail.get_connection(), locmem.EmailBackend)
True
# Test connection argument of send_mail() et al
>>> connection = mail.get_connection('django.core.mail.backends.console.EmailBackend')
>>> send_mail('Subject', 'Content', 'from@example.com', ['to@example.com'], connection=connection)
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Subject: Subject
From: from@example.com
To: to@example.com
Date: ...
Message-ID: ...
Content
-------------------------------------------------------------------------------
1
>>> send_mass_mail([
... ('Subject1', 'Content1', 'from1@example.com', ['to1@example.com']),
... ('Subject2', 'Content2', 'from2@example.com', ['to2@example.com'])
... ], connection=connection)
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Subject: Subject1
From: from1@example.com
To: to1@example.com
Date: ...
Message-ID: ...
Content1
-------------------------------------------------------------------------------
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Subject: Subject2
From: from2@example.com
To: to2@example.com
Date: ...
Message-ID: ...
Content2
-------------------------------------------------------------------------------
2
>>> mail_admins('Subject', 'Content', connection=connection)
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Subject: [Django] Subject
From: root@localhost
To: nobody@example.com
Date: ...
Message-ID: ...
Content
-------------------------------------------------------------------------------
>>> mail_managers('Subject', 'Content', connection=connection)
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Subject: [Django] Subject
From: root@localhost
To: nobody@example.com
Date: ...
Message-ID: ...
Content
-------------------------------------------------------------------------------
>>> settings.ADMINS = old_admins
>>> settings.MANAGERS = old_managers
# Add Cc to the email argument list (#7722)
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'], cc=['cc@example.com'])
>>> message = email.message()
>>> message['Cc']
'cc@example.com'
>>> email.recipients()
['to@example.com', 'cc@example.com']
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com','other@example.com'], cc=['cc@example.com', 'cc.other@example.com'])
>>> message = email.message()
>>> message['Cc']
'cc@example.com, cc.other@example.com'
>>> email.recipients()
['to@example.com', 'other@example.com', 'cc@example.com', 'cc.other@example.com']
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com','other@example.com'], cc=['cc@example.com', 'cc.other@example.com'], bcc=['bcc@example.com'])
>>> message = email.message()
>>> email.recipients()
['to@example.com', 'other@example.com', 'cc@example.com', 'cc.other@example.com', 'bcc@example.com']
>>> email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'], cc=['cc@example.com'])
>>> message = email.message()
>>> message.as_string()
'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nCc: cc@example.com\nDate: ...\nMessage-ID: <...>\n\nContent'
"""