def enclosed_message_test():
message = scan(ENCLOSED)
pmessage = _email.message_from_string(ENCLOSED)
eq_(
C('multipart', 'mixed',
dict(boundary='===============6195527458677812340==')),
message.content_type)
eq_(u'"Александр Клижентас☯" <*****@*****.**>', message.headers['To'])
eq_(pmessage.get_payload()[0].get_payload(), message.parts[0].body)
enclosed = message.parts[1]
penclosed = pmessage.get_payload(1)
eq_((
'message/rfc822',
{
'name': u'thanks.eml'
},
), enclosed.headers['Content-Type'])
pbody = penclosed.get_payload()[0].get_payload()[0].get_payload(
decode=True)
pbody = pbody.decode('utf-8')
body = enclosed.enclosed.parts[0].body
eq_(pbody, body)
body = enclosed.enclosed.parts[1].body
pbody = penclosed.get_payload()[0].get_payload()[1].get_payload(
decode=True)
pbody = pbody.decode('utf-8')
eq_(pbody, body)
def no_ctype_headers_and_and_boundaries_test():
"""We are ok, when there is no content type and boundaries"""
message = scan(NO_CTYPE)
eq_(C('text', 'plain', dict(charset='ascii')), message.content_type)
pmessage = _email.message_from_string(NO_CTYPE)
eq_(message.body, pmessage.get_payload(decode=True).decode('utf-8'))
for a, b in zip(NO_CTYPE_HEADERS, message.headers.iteritems()):
eq_(a, b)
def references_test():
# Given
message = create.from_python(
_email.message_from_string(MULTI_RECEIVED_HEADERS))
# When/Then
eq_({'[email protected]',
'*****@*****.**'},
set(message.references))
def create_singlepart_ascii_long_lines_test():
very_long = "very long line " * 1000 + "preserve my newlines \r\n\r\n"
message = create.text("plain", very_long)
message2 = create.from_string(message.to_string())
eq_("quoted-printable", message2.content_encoding.value)
eq_(very_long, message2.body)
message2 = _email.message_from_string(message.to_string())
eq_(very_long, message2.get_payload(decode=True).decode('utf-8'))
def create_singlepart_ascii_long_lines_test():
very_long = "very long line " * 1000 + "preserve my newlines \r\n\r\n"
message = create.text("plain", very_long)
message2 = create.from_string(message.to_string())
eq_("quoted-printable", message2.content_encoding.value)
eq_(very_long, message2.body)
message2 = _email.message_from_string(message.to_string())
eq_(very_long, message2.get_payload(decode=True).decode('utf-8'))
def multipart_message_test():
message = scan(EIGHT_BIT)
pmessage = _email.message_from_string(EIGHT_BIT)
eq_(C('multipart', 'alternative', dict(boundary='=-omjqkVTVbwdgCWFRgIkx')),
message.content_type)
p = unicode(pmessage.get_payload()[0].get_payload(decode=True), 'utf-8')
eq_(p, message.parts[0].body)
p = pmessage.get_payload()[1].get_payload(decode=True)
eq_(p, message.parts[1].body)
def from_python_message_test():
python_message = _email.message_from_string(MULTIPART)
message = scan(python_message.as_string())
eq_(python_message['Subject'], message.headers['Subject'])
ctypes = [p.get_content_type() for p in python_message.walk()]
ctypes2 = [p.headers['Content-Type'][0] \
for p in message.walk(with_self=True)]
eq_(ctypes, ctypes2)
payloads = [p.get_payload(decode=True) for p in python_message.walk()][1:]
payloads2 = [p.body for p in message.walk()]
eq_(payloads, payloads2)
def bad_python_test():
message = create.from_python(
_email.message_from_string("Content-Type:multipart/broken"))
ok_(message.to_string())
with closing(StringIO()) as out:
message.to_stream(out)
ok_(out.getvalue())
list(message.walk())
message.remove_headers()
assert_false(message.is_attachment())
assert_false(message.is_inline())
assert_false(message.is_delivery_notification())
assert_false(message.is_bounce())
ok_(message.to_python_message())
eq_(None, message.get_attached_message())
ok_(str(message))
def create_multipart_simple_test():
message = create.multipart("mixed")
message.append(create.text("plain", "Hello"),
create.text("html", "<html>Hello</html>"))
ok_(message.is_root())
assert_false(message.parts[0].is_root())
assert_false(message.parts[1].is_root())
message2 = create.from_string(message.to_string())
eq_(2, len(message2.parts))
eq_("multipart/mixed", message2.content_type)
eq_(2, len(message.parts))
eq_("Hello", message.parts[0].body)
eq_("<html>Hello</html>", message.parts[1].body)
message2 = _email.message_from_string(message.to_string())
eq_("multipart/mixed", message2.get_content_type())
eq_("Hello", message2.get_payload()[0].get_payload(decode=False))
eq_("<html>Hello</html>",
message2.get_payload()[1].get_payload(decode=False))
def create_multipart_with_attachment_test():
message = create.multipart("mixed")
filename = u"Мейлган картиночка картиночечка с длинным именем и пробельчиками"
message.append(
create.text("plain", "Hello"), create.text("html",
"<html>Hello</html>"),
create.binary("image", "png", MAILGUN_PNG, filename, "attachment"))
eq_(3, len(message.parts))
message2 = create.from_string(message.to_string())
eq_(3, len(message2.parts))
eq_("base64", message2.parts[2].content_encoding.value)
eq_(MAILGUN_PNG, message2.parts[2].body)
eq_(filename, message2.parts[2].content_disposition.params['filename'])
eq_(filename, message2.parts[2].content_type.params['name'])
ok_(message2.parts[2].is_attachment())
message2 = _email.message_from_string(message.to_string())
eq_(3, len(message2.get_payload()))
eq_(MAILGUN_PNG, message2.get_payload()[2].get_payload(decode=True))
def from_python_message_test():
python_message = _email.message_from_string(MULTIPART)
message = scan(python_message.as_string())
eq_(python_message['Subject'], message.headers['Subject'])
ctypes = [p.get_content_type() for p in python_message.walk()]
ctypes2 = [p.headers['Content-Type'][0]
for p in message.walk(with_self=True)]
eq_(ctypes, ctypes2)
payloads = []
for p in python_message.walk():
payload = p.get_payload(decode=True)
if payload:
payload = payload.decode('utf-8')
payloads.append(payload)
payloads2 = [p.body for p in message.walk()]
eq_(payloads[1:], payloads2)
def create_multipart_simple_test():
message = create.multipart("mixed")
message.append(
create.text("plain", "Hello"),
create.text("html", "<html>Hello</html>"))
ok_(message.is_root())
assert_false(message.parts[0].is_root())
assert_false(message.parts[1].is_root())
message2 = create.from_string(message.to_string())
eq_(2, len(message2.parts))
eq_("multipart/mixed", message2.content_type)
eq_(2, len(message.parts))
eq_("Hello", message.parts[0].body)
eq_("<html>Hello</html>", message.parts[1].body)
message2 = _email.message_from_string(message.to_string())
eq_("multipart/mixed", message2.get_content_type())
eq_("Hello", message2.get_payload()[0].get_payload(decode=False))
eq_("<html>Hello</html>",
message2.get_payload()[1].get_payload(decode=False))
def create_multipart_with_attachment_test():
message = create.multipart("mixed")
filename = u"Мейлган картиночка картиночечка с длинным именем и пробельчиками"
message.append(
create.text("plain", "Hello"),
create.text("html", "<html>Hello</html>"),
create.binary(
"image", "png", MAILGUN_PNG,
filename, "attachment"))
eq_(3, len(message.parts))
message2 = create.from_string(message.to_string())
eq_(3, len(message2.parts))
eq_("base64", message2.parts[2].content_encoding.value)
eq_(MAILGUN_PNG, message2.parts[2].body)
eq_(filename, message2.parts[2].content_disposition.params['filename'])
eq_(filename, message2.parts[2].content_type.params['name'])
ok_(message2.parts[2].is_attachment())
message2 = _email.message_from_string(message.to_string())
eq_(3, len(message2.get_payload()))
eq_(MAILGUN_PNG, message2.get_payload()[2].get_payload(decode=True))
def readonly_immutability_test():
message = scan(BILINGUAL)
eq_(u"Simple text. How are you? Как ты поживаешь?",
message.headers['Subject'])
assert_false(message.was_changed())
eq_(BILINGUAL, message.to_string())
message = scan(ENCLOSED)
pmessage = _email.message_from_string(ENCLOSED)
# we can read the headers without changing anything
eq_(u'"Александр Клижентас☯" <*****@*****.**>', message.headers['To'])
eq_('Bob Marley <*****@*****.**>, Jimmy Hendrix <*****@*****.**>',
message.parts[1].enclosed.headers['To'])
assert_false(message.was_changed())
# we can also read the body without changing anything
pbody = pmessage.get_payload()[1].get_payload()[0].get_payload(
)[0].get_payload(decode=True)
pbody = unicode(pbody, 'utf-8')
eq_(pbody, message.parts[1].enclosed.parts[0].body)
assert_false(message.was_changed())
eq_(ENCLOSED, message.to_string())
def readonly_immutability_test():
message = scan(BILINGUAL)
eq_(u"Simple text. How are you? Как ты поживаешь?",
message.headers['Subject'])
assert_false(message.was_changed())
eq_(BILINGUAL, message.to_string())
message = scan(ENCLOSED)
pmessage = _email.message_from_string(ENCLOSED)
# we can read the headers without changing anything
eq_(u'"Александр Клижентас☯" <*****@*****.**>',
message.headers['To'])
eq_('Bob Marley <*****@*****.**>, Jimmy Hendrix <*****@*****.**>',
message.parts[1].enclosed.headers['To'])
assert_false(message.was_changed())
# we can also read the body without changing anything
pbody = pmessage.get_payload()[1].get_payload()[0].get_payload()[0].get_payload(decode=True)
pbody = pbody.decode('utf-8')
eq_(pbody, message.parts[1].enclosed.parts[0].body)
assert_false(message.was_changed())
eq_(ENCLOSED, message.to_string())
def to_python_message(self):
return _email.message_from_string(self.to_string())
def to_python_message(self):
return _email.message_from_string(self.to_string())
def from_string(string):
return FallbackMimePart(_email.message_from_string(string))
def append(self, *messages):
for m in messages:
part = FallbackMimePart(_email.message_from_string(m.to_string()))
self._m.attach(part)
