mirror of
https://github.com/pacnpal/django-anymail.git
synced 2025-12-20 11:51:05 -05:00
6b6793016e
[RFC-5322 allows](https://tools.ietf.org/html/rfc5322#section-3.6.2) multiple addresses in the From header. Django's SMTP backend supports this, as a single comma-separated string (*not* a list of strings like the recipient params): from_email='one@example.com, two@example.com' to=['one@example.com', 'two@example.com'] Both Mailgun and SparkPost support multiple From addresses (and Postmark accepts them, though truncates to the first one on their end). For compatibility with Django -- and because Anymail attempts to support all ESP features -- Anymail now allows multiple From addresses, too, for ESPs that support it. Note: as a practical matter, deliverability with multiple From addresses is pretty bad. (Google outright rejects them.) This change also reworks Anymail's internal ParsedEmail object, and approach to parsing addresses, for better consistency with Django's SMTP backend and improved error messaging. In particular, Django (and now Anymail) allows multiple email addresses in a single recipient string: to=['one@example.com', 'two@example.com, three@example.com'] len(to) == 2 # but there will be three recipients Fixes #60
278 lines
13 KiB
Python
278 lines
13 KiB
Python
# Tests for the anymail/utils.py module
|
|
# (not to be confused with utilities for testing found in in tests/utils.py)
|
|
import base64
|
|
|
|
import six
|
|
from django.test import SimpleTestCase, RequestFactory, override_settings
|
|
from django.utils.translation import ugettext_lazy, string_concat
|
|
|
|
from anymail.exceptions import AnymailInvalidAddress
|
|
from anymail.utils import (parse_address_list, ParsedEmail,
|
|
is_lazy, force_non_lazy, force_non_lazy_dict, force_non_lazy_list,
|
|
update_deep,
|
|
get_request_uri, get_request_basic_auth)
|
|
|
|
|
|
class ParseAddressListTests(SimpleTestCase):
|
|
"""Test utils.parse_address_list"""
|
|
|
|
def test_simple_email(self):
|
|
parsed_list = parse_address_list(["test@example.com"])
|
|
self.assertEqual(len(parsed_list), 1)
|
|
parsed = parsed_list[0]
|
|
self.assertIsInstance(parsed, ParsedEmail)
|
|
self.assertEqual(parsed.email, "test@example.com")
|
|
self.assertEqual(parsed.name, "")
|
|
self.assertEqual(parsed.address, "test@example.com")
|
|
self.assertEqual(parsed.localpart, "test")
|
|
self.assertEqual(parsed.domain, "example.com")
|
|
|
|
def test_display_name(self):
|
|
parsed_list = parse_address_list(['"Display Name, Inc." <test@example.com>'])
|
|
self.assertEqual(len(parsed_list), 1)
|
|
parsed = parsed_list[0]
|
|
self.assertEqual(parsed.email, "test@example.com")
|
|
self.assertEqual(parsed.name, "Display Name, Inc.")
|
|
self.assertEqual(parsed.address, '"Display Name, Inc." <test@example.com>')
|
|
self.assertEqual(parsed.localpart, "test")
|
|
self.assertEqual(parsed.domain, "example.com")
|
|
|
|
def test_obsolete_display_name(self):
|
|
# you can get away without the quotes if there are no commas or parens
|
|
# (but it's not recommended)
|
|
parsed_list = parse_address_list(['Display Name <test@example.com>'])
|
|
self.assertEqual(len(parsed_list), 1)
|
|
parsed = parsed_list[0]
|
|
self.assertEqual(parsed.email, "test@example.com")
|
|
self.assertEqual(parsed.name, "Display Name")
|
|
self.assertEqual(parsed.address, 'Display Name <test@example.com>')
|
|
|
|
def test_unicode_display_name(self):
|
|
parsed_list = parse_address_list([u'"Unicode \N{HEAVY BLACK HEART}" <test@example.com>'])
|
|
self.assertEqual(len(parsed_list), 1)
|
|
parsed = parsed_list[0]
|
|
self.assertEqual(parsed.email, "test@example.com")
|
|
self.assertEqual(parsed.name, u"Unicode \N{HEAVY BLACK HEART}")
|
|
# formatted display-name automatically shifts to quoted-printable/base64 for non-ascii chars:
|
|
self.assertEqual(parsed.address, '=?utf-8?b?VW5pY29kZSDinaQ=?= <test@example.com>')
|
|
|
|
def test_invalid_display_name(self):
|
|
with self.assertRaisesMessage(AnymailInvalidAddress, "Invalid email address 'webmaster'"):
|
|
parse_address_list(['webmaster'])
|
|
|
|
with self.assertRaisesMessage(AnymailInvalidAddress, "Maybe missing quotes around a display-name?"):
|
|
# this parses as multiple email addresses, because of the comma:
|
|
parse_address_list(['Display Name, Inc. <test@example.com>'])
|
|
|
|
def test_idn(self):
|
|
parsed_list = parse_address_list([u"idn@\N{ENVELOPE}.example.com"])
|
|
self.assertEqual(len(parsed_list), 1)
|
|
parsed = parsed_list[0]
|
|
self.assertEqual(parsed.email, u"idn@\N{ENVELOPE}.example.com")
|
|
self.assertEqual(parsed.address, "idn@xn--4bi.example.com") # punycode-encoded domain
|
|
self.assertEqual(parsed.localpart, "idn")
|
|
self.assertEqual(parsed.domain, u"\N{ENVELOPE}.example.com")
|
|
|
|
def test_none_address(self):
|
|
# used for, e.g., telling Mandrill to use template default from_email
|
|
self.assertEqual(parse_address_list([None]), [])
|
|
self.assertEqual(parse_address_list(None), [])
|
|
|
|
def test_empty_address(self):
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list([''])
|
|
|
|
def test_whitespace_only_address(self):
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list([' '])
|
|
|
|
def test_invalid_address(self):
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list(['localonly'])
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list(['localonly@'])
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list(['@domainonly'])
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list(['<localonly@>'])
|
|
with self.assertRaises(AnymailInvalidAddress):
|
|
parse_address_list(['<@domainonly>'])
|
|
|
|
def test_email_list(self):
|
|
parsed_list = parse_address_list(["first@example.com", "second@example.com"])
|
|
self.assertEqual(len(parsed_list), 2)
|
|
self.assertEqual(parsed_list[0].email, "first@example.com")
|
|
self.assertEqual(parsed_list[1].email, "second@example.com")
|
|
|
|
def test_multiple_emails(self):
|
|
# Django's EmailMessage allows multiple, comma-separated emails
|
|
# in a single recipient string. (It passes them along to the backend intact.)
|
|
# (Depending on this behavior is not recommended.)
|
|
parsed_list = parse_address_list(["first@example.com, second@example.com"])
|
|
self.assertEqual(len(parsed_list), 2)
|
|
self.assertEqual(parsed_list[0].email, "first@example.com")
|
|
self.assertEqual(parsed_list[1].email, "second@example.com")
|
|
|
|
def test_invalid_in_list(self):
|
|
# Make sure it's not just concatenating list items...
|
|
# the bare "Display Name" below should *not* get merged with
|
|
# the email in the second item
|
|
with self.assertRaisesMessage(AnymailInvalidAddress, "Display Name"):
|
|
parse_address_list(['"Display Name"', '<valid@example.com>'])
|
|
|
|
def test_single_string(self):
|
|
# bare strings are used by the from_email parsing in BasePayload
|
|
parsed_list = parse_address_list("one@example.com")
|
|
self.assertEqual(len(parsed_list), 1)
|
|
self.assertEqual(parsed_list[0].email, "one@example.com")
|
|
|
|
def test_lazy_strings(self):
|
|
parsed_list = parse_address_list([ugettext_lazy('"Example, Inc." <one@example.com>')])
|
|
self.assertEqual(len(parsed_list), 1)
|
|
self.assertEqual(parsed_list[0].name, "Example, Inc.")
|
|
self.assertEqual(parsed_list[0].email, "one@example.com")
|
|
|
|
parsed_list = parse_address_list(ugettext_lazy("one@example.com"))
|
|
self.assertEqual(len(parsed_list), 1)
|
|
self.assertEqual(parsed_list[0].name, "")
|
|
self.assertEqual(parsed_list[0].email, "one@example.com")
|
|
|
|
|
|
class LazyCoercionTests(SimpleTestCase):
|
|
"""Test utils.is_lazy and force_non_lazy*"""
|
|
|
|
def test_is_lazy(self):
|
|
self.assertTrue(is_lazy(ugettext_lazy("lazy string is lazy")))
|
|
self.assertTrue(is_lazy(string_concat(ugettext_lazy("concatenation"),
|
|
ugettext_lazy("is lazy"))))
|
|
|
|
def test_not_lazy(self):
|
|
self.assertFalse(is_lazy(u"text not lazy"))
|
|
self.assertFalse(is_lazy(b"bytes not lazy"))
|
|
self.assertFalse(is_lazy(None))
|
|
self.assertFalse(is_lazy({'dict': "not lazy"}))
|
|
self.assertFalse(is_lazy(["list", "not lazy"]))
|
|
self.assertFalse(is_lazy(object()))
|
|
self.assertFalse(is_lazy([ugettext_lazy("doesn't recurse")]))
|
|
|
|
def test_force_lazy(self):
|
|
result = force_non_lazy(ugettext_lazy(u"text"))
|
|
self.assertIsInstance(result, six.text_type)
|
|
self.assertEqual(result, u"text")
|
|
|
|
def test_force_concat(self):
|
|
result = force_non_lazy(string_concat(ugettext_lazy(u"text"), ugettext_lazy("concat")))
|
|
self.assertIsInstance(result, six.text_type)
|
|
self.assertEqual(result, u"textconcat")
|
|
|
|
def test_force_string(self):
|
|
result = force_non_lazy(u"text")
|
|
self.assertIsInstance(result, six.text_type)
|
|
self.assertEqual(result, u"text")
|
|
|
|
def test_force_bytes(self):
|
|
result = force_non_lazy(b"bytes \xFE")
|
|
self.assertIsInstance(result, six.binary_type)
|
|
self.assertEqual(result, b"bytes \xFE")
|
|
|
|
def test_force_none(self):
|
|
result = force_non_lazy(None)
|
|
self.assertIsNone(result)
|
|
|
|
def test_force_dict(self):
|
|
result = force_non_lazy_dict({'a': 1, 'b': ugettext_lazy(u"b"),
|
|
'c': {'c1': ugettext_lazy(u"c1")}})
|
|
self.assertEqual(result, {'a': 1, 'b': u"b", 'c': {'c1': u"c1"}})
|
|
self.assertIsInstance(result['b'], six.text_type)
|
|
self.assertIsInstance(result['c']['c1'], six.text_type)
|
|
|
|
def test_force_list(self):
|
|
result = force_non_lazy_list([0, ugettext_lazy(u"b"), u"c"])
|
|
self.assertEqual(result, [0, u"b", u"c"]) # coerced to list
|
|
self.assertIsInstance(result[1], six.text_type)
|
|
|
|
|
|
class UpdateDeepTests(SimpleTestCase):
|
|
"""Test utils.update_deep"""
|
|
|
|
def test_updates_recursively(self):
|
|
first = {'a': {'a1': 1, 'aa': {}}, 'b': "B"}
|
|
second = {'a': {'a2': 2, 'aa': {'aa1': 11}}}
|
|
result = update_deep(first, second)
|
|
self.assertEqual(first, {'a': {'a1': 1, 'a2': 2, 'aa': {'aa1': 11}}, 'b': "B"})
|
|
self.assertIsNone(result) # modifies first in place; doesn't return it (same as dict.update())
|
|
|
|
def test_overwrites_sequences(self):
|
|
"""Only mappings are handled recursively; sequences are considered atomic"""
|
|
first = {'a': [1, 2]}
|
|
second = {'a': [3]}
|
|
update_deep(first, second)
|
|
self.assertEqual(first, {'a': [3]})
|
|
|
|
def test_handles_non_dict_mappings(self):
|
|
"""Mapping types in general are supported"""
|
|
from collections import OrderedDict, defaultdict
|
|
first = OrderedDict(a=OrderedDict(a1=1), c={'c1': 1})
|
|
second = defaultdict(None, a=dict(a2=2))
|
|
update_deep(first, second)
|
|
self.assertEqual(first, {'a': {'a1': 1, 'a2': 2}, 'c': {'c1': 1}})
|
|
|
|
|
|
@override_settings(ALLOWED_HOSTS=[".example.com"])
|
|
class RequestUtilsTests(SimpleTestCase):
|
|
"""Test utils.get_request_* helpers"""
|
|
|
|
def setUp(self):
|
|
self.request_factory = RequestFactory()
|
|
super(RequestUtilsTests, self).setUp()
|
|
|
|
@staticmethod
|
|
def basic_auth(username, password):
|
|
"""Return HTTP_AUTHORIZATION header value for basic auth with username, password"""
|
|
credentials = base64.b64encode("{}:{}".format(username, password).encode('utf-8')).decode('utf-8')
|
|
return "Basic {}".format(credentials)
|
|
|
|
def test_get_request_basic_auth(self):
|
|
# without auth:
|
|
request = self.request_factory.post('/path/to/?query',
|
|
HTTP_HOST='www.example.com',
|
|
HTTP_SCHEME='https')
|
|
self.assertIsNone(get_request_basic_auth(request))
|
|
|
|
# with basic auth:
|
|
request = self.request_factory.post('/path/to/?query',
|
|
HTTP_HOST='www.example.com',
|
|
HTTP_AUTHORIZATION=self.basic_auth('user', 'pass'))
|
|
self.assertEqual(get_request_basic_auth(request), "user:pass")
|
|
|
|
# with some other auth
|
|
request = self.request_factory.post('/path/to/?query',
|
|
HTTP_HOST='www.example.com',
|
|
HTTP_AUTHORIZATION="Bearer abcde12345")
|
|
self.assertIsNone(get_request_basic_auth(request))
|
|
|
|
def test_get_request_uri(self):
|
|
# without auth:
|
|
request = self.request_factory.post('/path/to/?query', secure=True,
|
|
HTTP_HOST='www.example.com')
|
|
self.assertEqual(get_request_uri(request),
|
|
"https://www.example.com/path/to/?query")
|
|
|
|
# with basic auth:
|
|
request = self.request_factory.post('/path/to/?query', secure=True,
|
|
HTTP_HOST='www.example.com',
|
|
HTTP_AUTHORIZATION=self.basic_auth('user', 'pass'))
|
|
self.assertEqual(get_request_uri(request),
|
|
"https://user:pass@www.example.com/path/to/?query")
|
|
|
|
@override_settings(SECURE_PROXY_SSL_HEADER=('HTTP_X_FORWARDED_PROTO', 'https'),
|
|
USE_X_FORWARDED_HOST=True)
|
|
def test_get_request_uri_with_proxy(self):
|
|
request = self.request_factory.post('/path/to/?query', secure=False,
|
|
HTTP_HOST='web1.internal',
|
|
HTTP_X_FORWARDED_PROTO='https',
|
|
HTTP_X_FORWARDED_HOST='secret.example.com:8989',
|
|
HTTP_AUTHORIZATION=self.basic_auth('user', 'pass'))
|
|
self.assertEqual(get_request_uri(request),
|
|
"https://user:pass@secret.example.com:8989/path/to/?query")
|