798 lines
24 KiB
Python
798 lines
24 KiB
Python
# Copyright (C) 2001 Python Software Foundation
|
||
# email package unit tests
|
||
|
||
import os
|
||
import time
|
||
import unittest
|
||
import base64
|
||
from cStringIO import StringIO
|
||
from types import StringType
|
||
|
||
import email
|
||
|
||
from email.Parser import Parser
|
||
from email.Generator import Generator, DecodedGenerator
|
||
from email.Message import Message
|
||
from email.Text import Text
|
||
from email.Image import Image
|
||
from email.MIMEBase import MIMEBase
|
||
from email.MessageRFC822 import MessageRFC822
|
||
from email import Utils
|
||
from email import Errors
|
||
from email import Encoders
|
||
from email import Iterators
|
||
|
||
import test.regrtest
|
||
|
||
NL = '\n'
|
||
EMPTYSTRING = ''
|
||
|
||
|
||
|
||
def openfile(filename):
|
||
path = os.path.join(os.path.dirname(test.regrtest.__file__),
|
||
'data', filename)
|
||
return open(path)
|
||
|
||
|
||
|
||
# Base test class
|
||
class TestEmailBase(unittest.TestCase):
|
||
def _msgobj(self, filename):
|
||
fp = openfile(filename)
|
||
try:
|
||
msgobj = email.message_from_file(fp)
|
||
finally:
|
||
fp.close()
|
||
return msgobj
|
||
|
||
|
||
|
||
# Test various aspects of the Message class's API
|
||
class TestMessageAPI(TestEmailBase):
|
||
def test_get_charsets(self):
|
||
eq = self.assertEqual
|
||
|
||
msgobj = self._msgobj('msg_08.txt')
|
||
charsets = msgobj.get_charsets()
|
||
eq(charsets, ['us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])
|
||
|
||
msgobj = self._msgobj('msg_09.txt')
|
||
charsets = msgobj.get_charsets('dingbat')
|
||
eq(charsets, ['us-ascii', 'iso-8859-1', 'dingbat', 'koi8-r'])
|
||
|
||
msgobj = self._msgobj('msg_12.txt')
|
||
charsets = msgobj.get_charsets()
|
||
eq(charsets, ['us-ascii', 'iso-8859-1', 'iso-8859-2', 'iso-8859-3',
|
||
'us-ascii', 'koi8-r'])
|
||
|
||
def test_get_filename(self):
|
||
eq = self.assertEqual
|
||
|
||
msgobj = self._msgobj('msg_04.txt')
|
||
filenames = [p.get_filename() for p in msgobj.get_payload()]
|
||
eq(filenames, ['msg.txt', 'msg.txt'])
|
||
|
||
msgobj = self._msgobj('msg_07.txt')
|
||
subpart = msgobj.get_payload(1)
|
||
eq(subpart.get_filename(), 'dingusfish.gif')
|
||
|
||
def test_get_boundary(self):
|
||
eq = self.assertEqual
|
||
msgobj = self._msgobj('msg_07.txt')
|
||
# No quotes!
|
||
eq(msgobj.get_boundary(), 'BOUNDARY')
|
||
|
||
def test_set_boundary(self):
|
||
eq = self.assertEqual
|
||
# This one has no existing boundary parameter, but the Content-Type:
|
||
# header appears fifth.
|
||
msgobj = self._msgobj('msg_01.txt')
|
||
msgobj.set_boundary('BOUNDARY')
|
||
header, value = msgobj.items()[4]
|
||
eq(header.lower(), 'content-type')
|
||
eq(value, 'text/plain; charset=us-ascii; boundary="BOUNDARY"')
|
||
# This one has a Content-Type: header, with a boundary, stuck in the
|
||
# middle of its headers. Make sure the order is preserved; it should
|
||
# be fifth.
|
||
msgobj = self._msgobj('msg_04.txt')
|
||
msgobj.set_boundary('BOUNDARY')
|
||
header, value = msgobj.items()[4]
|
||
eq(header.lower(), 'content-type')
|
||
eq(value, 'multipart/mixed; boundary="BOUNDARY"')
|
||
# And this one has no Content-Type: header at all.
|
||
msgobj = self._msgobj('msg_03.txt')
|
||
self.assertRaises(Errors.HeaderParseError,
|
||
msgobj.set_boundary, 'BOUNDARY')
|
||
|
||
def test_get_decoded_payload(self):
|
||
eq = self.assertEqual
|
||
msgobj = self._msgobj('msg_10.txt')
|
||
# The outer message is a multipart
|
||
eq(msgobj.get_payload(decode=1), None)
|
||
# Subpart 1 is 7bit encoded
|
||
eq(msgobj.get_payload(0).get_payload(decode=1),
|
||
'This is a 7bit encoded message.\n')
|
||
# Subpart 2 is quopri
|
||
eq(msgobj.get_payload(1).get_payload(decode=1),
|
||
'\xa1This is a Quoted Printable encoded message!\n')
|
||
# Subpart 3 is base64
|
||
eq(msgobj.get_payload(2).get_payload(decode=1),
|
||
'This is a Base64 encoded message.')
|
||
# Subpart 4 has no Content-Transfer-Encoding: header.
|
||
eq(msgobj.get_payload(3).get_payload(decode=1),
|
||
'This has no Content-Transfer-Encoding: header.\n')
|
||
|
||
def test_decoded_generator(self):
|
||
eq = self.assertEqual
|
||
msgobj = self._msgobj('msg_07.txt')
|
||
s = StringIO()
|
||
g = DecodedGenerator(s)
|
||
g(msgobj)
|
||
eq(s.getvalue(), '''\
|
||
MIME-Version: 1.0
|
||
From: Barry <barry@digicool.com>
|
||
To: Dingus Lovers <cravindogs@cravindogs.com>
|
||
Subject: Here is your dingus fish
|
||
Date: Fri, 20 Apr 2001 19:35:02 -0400
|
||
Content-Type: multipart/mixed; boundary="BOUNDARY"
|
||
|
||
Hi there,
|
||
|
||
This is the dingus fish.
|
||
|
||
[Non-text (image/gif) part of message omitted, filename dingusfish.gif]
|
||
''')
|
||
|
||
def test__contains__(self):
|
||
msg = Message()
|
||
msg['From'] = 'Me'
|
||
msg['to'] = 'You'
|
||
# Check for case insensitivity
|
||
self.failUnless('from' in msg)
|
||
self.failUnless('From' in msg)
|
||
self.failUnless('FROM' in msg)
|
||
self.failUnless('to' in msg)
|
||
self.failUnless('To' in msg)
|
||
self.failUnless('TO' in msg)
|
||
|
||
def test_as_string(self):
|
||
eq = self.assertEqual
|
||
msgobj = self._msgobj('msg_01.txt')
|
||
fp = openfile('msg_01.txt')
|
||
try:
|
||
text = fp.read()
|
||
finally:
|
||
fp.close()
|
||
eq(text, msgobj.as_string())
|
||
fullrepr = str(msgobj)
|
||
lines = fullrepr.split('\n')
|
||
self.failUnless(lines[0].startswith('From '))
|
||
eq(text, NL.join(lines[1:]))
|
||
|
||
def test_bad_param(self):
|
||
msg = email.message_from_string("""\
|
||
From: foo
|
||
Content-Type: blarg; baz; boo
|
||
|
||
""")
|
||
self.assertEqual(msg.get_param('baz'), '')
|
||
|
||
def test_missing_filename(self):
|
||
msg = email.message_from_string("""\
|
||
From: foo
|
||
|
||
""")
|
||
self.assertEqual(msg.get_filename(), None)
|
||
|
||
def test_bogus_filename(self):
|
||
msg = email.message_from_string("""\
|
||
From: foo
|
||
Content-Disposition: blarg; filename
|
||
|
||
""")
|
||
self.assertEqual(msg.get_filename(), '')
|
||
|
||
def test_missing_boundary(self):
|
||
msg = email.message_from_string("""\
|
||
From: foo
|
||
|
||
""")
|
||
self.assertEqual(msg.get_boundary(), None)
|
||
|
||
|
||
|
||
# Test the email.Encoders module
|
||
class TestEncoders(unittest.TestCase):
|
||
def test_encode_noop(self):
|
||
eq = self.assertEqual
|
||
msg = Text('hello world', _encoder=Encoders.encode_noop)
|
||
eq(msg.get_payload(), 'hello world\n')
|
||
eq(msg['content-transfer-encoding'], None)
|
||
|
||
def test_encode_7bit(self):
|
||
eq = self.assertEqual
|
||
msg = Text('hello world', _encoder=Encoders.encode_7or8bit)
|
||
eq(msg.get_payload(), 'hello world\n')
|
||
eq(msg['content-transfer-encoding'], '7bit')
|
||
msg = Text('hello \x7f world', _encoder=Encoders.encode_7or8bit)
|
||
eq(msg.get_payload(), 'hello \x7f world\n')
|
||
eq(msg['content-transfer-encoding'], '7bit')
|
||
|
||
def test_encode_8bit(self):
|
||
eq = self.assertEqual
|
||
msg = Text('hello \x80 world', _encoder=Encoders.encode_7or8bit)
|
||
eq(msg.get_payload(), 'hello \x80 world\n')
|
||
eq(msg['content-transfer-encoding'], '8bit')
|
||
|
||
def test_encode_base64(self):
|
||
eq = self.assertEqual
|
||
msg = Text('hello world', _encoder=Encoders.encode_base64)
|
||
eq(msg.get_payload(), 'aGVsbG8gd29ybGQK\n')
|
||
eq(msg['content-transfer-encoding'], 'base64')
|
||
|
||
def test_encode_quoted_printable(self):
|
||
eq = self.assertEqual
|
||
msg = Text('hello world', _encoder=Encoders.encode_quopri)
|
||
eq(msg.get_payload(), 'hello=20world\n')
|
||
eq(msg['content-transfer-encoding'], 'quoted-printable')
|
||
|
||
|
||
|
||
class TestLongHeaders(unittest.TestCase):
|
||
def test_header_splitter(self):
|
||
msg = Text('')
|
||
# It'd be great if we could use add_header() here, but that doesn't
|
||
# guarantee an order of the parameters.
|
||
msg['X-Foobar-Spoink-Defrobnit'] = (
|
||
'wasnipoop; giraffes="very-long-necked-animals"; '
|
||
'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"')
|
||
sfp = StringIO()
|
||
g = Generator(sfp)
|
||
g(msg)
|
||
self.assertEqual(sfp.getvalue(), '''\
|
||
Content-Type: text/plain; charset="us-ascii"
|
||
MIME-Version: 1.0
|
||
Content-Transfer-Encoding: 7bit
|
||
X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
|
||
spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
|
||
|
||
''')
|
||
|
||
|
||
|
||
class TestFromMangling(unittest.TestCase):
|
||
def setUp(self):
|
||
self.msg = Message()
|
||
self.msg['From'] = 'aaa@bbb.org'
|
||
self.msg.add_payload("""\
|
||
From the desk of A.A.A.:
|
||
Blah blah blah
|
||
""")
|
||
|
||
def test_mangled_from(self):
|
||
s = StringIO()
|
||
g = Generator(s, mangle_from_=1)
|
||
g(self.msg)
|
||
self.assertEqual(s.getvalue(), """\
|
||
From: aaa@bbb.org
|
||
|
||
>From the desk of A.A.A.:
|
||
Blah blah blah
|
||
""")
|
||
|
||
def test_dont_mangle_from(self):
|
||
s = StringIO()
|
||
g = Generator(s, mangle_from_=0)
|
||
g(self.msg)
|
||
self.assertEqual(s.getvalue(), """\
|
||
From: aaa@bbb.org
|
||
|
||
From the desk of A.A.A.:
|
||
Blah blah blah
|
||
""")
|
||
|
||
|
||
|
||
# Test the basic Image class
|
||
class TestImage(unittest.TestCase):
|
||
def setUp(self):
|
||
fp = openfile('PyBanner048.gif')
|
||
try:
|
||
self._imgdata = fp.read()
|
||
finally:
|
||
fp.close()
|
||
self._im = Image(self._imgdata)
|
||
|
||
def test_guess_minor_type(self):
|
||
self.assertEqual(self._im.get_type(), 'image/gif')
|
||
|
||
def test_encoding(self):
|
||
payload = self._im.get_payload()
|
||
self.assertEqual(base64.decodestring(payload), self._imgdata)
|
||
|
||
def checkSetMinor(self):
|
||
im = Image(self._imgdata, 'fish')
|
||
self.assertEqual(im.get_type(), 'image/fish')
|
||
|
||
def test_custom_encoder(self):
|
||
eq = self.assertEqual
|
||
def encoder(msg):
|
||
orig = msg.get_payload()
|
||
msg.set_payload(0)
|
||
msg['Content-Transfer-Encoding'] = 'broken64'
|
||
im = Image(self._imgdata, _encoder=encoder)
|
||
eq(im.get_payload(), 0)
|
||
eq(im['content-transfer-encoding'], 'broken64')
|
||
|
||
def test_add_header(self):
|
||
eq = self.assertEqual
|
||
unless = self.failUnless
|
||
self._im.add_header('Content-Disposition', 'attachment',
|
||
filename='dingusfish.gif')
|
||
eq(self._im['content-disposition'],
|
||
'attachment; filename="dingusfish.gif"')
|
||
eq(self._im.get_params(header='content-disposition'),
|
||
['filename="dingusfish.gif"'])
|
||
eq(self._im.get_param('filename', header='content-disposition'),
|
||
'dingusfish.gif')
|
||
missing = []
|
||
unless(self._im.get_param('attachment', missing,
|
||
header='content-disposition') is missing)
|
||
# Try some missing stuff
|
||
unless(self._im.get_param('foobar', missing) is missing)
|
||
unless(self._im.get_param('attachment', missing,
|
||
header='foobar') is missing)
|
||
|
||
|
||
|
||
# Test the basic Text class
|
||
class TestText(unittest.TestCase):
|
||
def setUp(self):
|
||
self._msg = Text('hello there')
|
||
|
||
def test_types(self):
|
||
eq = self.assertEqual
|
||
unless = self.failUnless
|
||
eq(self._msg.get_type(), 'text/plain')
|
||
eq(self._msg.get_param('charset'), 'us-ascii')
|
||
missing = []
|
||
unless(self._msg.get_param('foobar', missing) is missing)
|
||
unless(self._msg.get_param('charset', missing, header='foobar')
|
||
is missing)
|
||
|
||
def test_payload(self):
|
||
self.assertEqual(self._msg.get_payload(), 'hello there\n')
|
||
self.failUnless(not self._msg.is_multipart())
|
||
|
||
|
||
|
||
class TestMultipartMixed(unittest.TestCase):
|
||
def setUp(self):
|
||
fp = openfile('PyBanner048.gif')
|
||
try:
|
||
data = fp.read()
|
||
finally:
|
||
fp.close()
|
||
|
||
container = MIMEBase('multipart', 'mixed', boundary='BOUNDARY')
|
||
image = Image(data, name='dingusfish.gif')
|
||
image.add_header('content-disposition', 'attachment',
|
||
filename='dingusfish.gif')
|
||
intro = Text('''\
|
||
Hi there,
|
||
|
||
This is the dingus fish.
|
||
''')
|
||
container.add_payload(intro)
|
||
container.add_payload(image)
|
||
container['From'] = 'Barry <barry@digicool.com>'
|
||
container['To'] = 'Dingus Lovers <cravindogs@cravindogs.com>'
|
||
container['Subject'] = 'Here is your dingus fish'
|
||
|
||
now = 987809702.54848599
|
||
timetuple = time.localtime(now)
|
||
if timetuple[-1] == 0:
|
||
tzsecs = time.timezone
|
||
else:
|
||
tzsecs = time.altzone
|
||
if tzsecs > 0:
|
||
sign = '-'
|
||
else:
|
||
sign = '+'
|
||
tzoffset = ' %s%04d' % (sign, tzsecs / 36)
|
||
container['Date'] = time.strftime(
|
||
'%a, %d %b %Y %H:%M:%S',
|
||
time.localtime(now)) + tzoffset
|
||
self._msg = container
|
||
self._im = image
|
||
self._txt = intro
|
||
|
||
def test_hierarchy(self):
|
||
# convenience
|
||
eq = self.assertEqual
|
||
unless = self.failUnless
|
||
raises = self.assertRaises
|
||
# tests
|
||
m = self._msg
|
||
unless(m.is_multipart())
|
||
eq(m.get_type(), 'multipart/mixed')
|
||
eq(len(m.get_payload()), 2)
|
||
raises(IndexError, m.get_payload, 2)
|
||
m0 = m.get_payload(0)
|
||
m1 = m.get_payload(1)
|
||
unless(m0 is self._txt)
|
||
unless(m1 is self._im)
|
||
eq(m.get_payload(), [m0, m1])
|
||
unless(not m0.is_multipart())
|
||
unless(not m1.is_multipart())
|
||
|
||
|
||
|
||
class TestNonConformant(TestEmailBase):
|
||
def test_parse_missing_minor_type(self):
|
||
eq = self.assertEqual
|
||
msg = self._msgobj('msg_14.txt')
|
||
eq(msg.get_type(), 'text')
|
||
eq(msg.get_main_type(), 'text')
|
||
self.failUnless(msg.get_subtype() is None)
|
||
|
||
def test_bogus_boundary(self):
|
||
fp = openfile('msg_15.txt')
|
||
try:
|
||
data = fp.read()
|
||
finally:
|
||
fp.close()
|
||
p = Parser()
|
||
# Note, under a future non-strict parsing mode, this would parse the
|
||
# message into the intended message tree.
|
||
self.assertRaises(Errors.BoundaryError, p.parsestr, data)
|
||
|
||
|
||
|
||
class TestRFC2047(unittest.TestCase):
|
||
def test_iso_8859_1(self):
|
||
eq = self.assertEqual
|
||
s = '=?iso-8859-1?q?this=20is=20some=20text?='
|
||
eq(Utils.decode(s), 'this is some text')
|
||
s = '=?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?='
|
||
eq(Utils.decode(s), u'Keld_J\xf8rn_Simonsen')
|
||
s = '=?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=' \
|
||
'=?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?='
|
||
eq(Utils.decode(s), 'If you can read this you understand the example.')
|
||
s = '=?iso-8859-8?b?7eXs+SDv4SDp7Oj08A==?='
|
||
eq(Utils.decode(s),
|
||
u'\u05dd\u05d5\u05dc\u05e9 \u05df\u05d1 \u05d9\u05dc\u05d8\u05e4\u05e0')
|
||
s = '=?iso-8859-1?q?this=20is?= =?iso-8859-1?q?some=20text?='
|
||
eq(Utils.decode(s), u'this is some text')
|
||
|
||
def test_encode_header(self):
|
||
eq = self.assertEqual
|
||
s = 'this is some text'
|
||
eq(Utils.encode(s), '=?iso-8859-1?q?this=20is=20some=20text?=')
|
||
s = 'Keld_J\xf8rn_Simonsen'
|
||
eq(Utils.encode(s), '=?iso-8859-1?q?Keld_J=F8rn_Simonsen?=')
|
||
s1 = 'If you can read this yo'
|
||
s2 = 'u understand the example.'
|
||
eq(Utils.encode(s1, encoding='b'),
|
||
'=?iso-8859-1?b?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=')
|
||
eq(Utils.encode(s2, charset='iso-8859-2', encoding='b'),
|
||
'=?iso-8859-2?b?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=')
|
||
|
||
|
||
|
||
class TestMessageRFC822(unittest.TestCase):
|
||
def setUp(self):
|
||
fp = openfile('msg_11.txt')
|
||
self._text = fp.read()
|
||
fp.close()
|
||
|
||
def test_type_error(self):
|
||
self.assertRaises(TypeError, MessageRFC822, 'a plain string')
|
||
|
||
def test_valid_argument(self):
|
||
eq = self.assertEqual
|
||
subject = 'A sub-message'
|
||
m = Message()
|
||
m['Subject'] = subject
|
||
r = MessageRFC822(m)
|
||
eq(r.get_type(), 'message/rfc822')
|
||
self.failUnless(r.get_payload() is m)
|
||
eq(r.get_payload()['subject'], subject)
|
||
|
||
def test_generate(self):
|
||
# First craft the message to be encapsulated
|
||
m = Message()
|
||
m['Subject'] = 'An enclosed message'
|
||
m.add_payload('Here is the body of the message.\n')
|
||
r = MessageRFC822(m)
|
||
r['Subject'] = 'The enclosing message'
|
||
s = StringIO()
|
||
g = Generator(s)
|
||
g(r)
|
||
self.assertEqual(s.getvalue(), self._text)
|
||
|
||
|
||
|
||
class TestIdempotent(unittest.TestCase):
|
||
def _msgobj(self, filename):
|
||
fp = openfile(filename)
|
||
try:
|
||
data = fp.read()
|
||
finally:
|
||
fp.close()
|
||
msgobj = email.message_from_string(data)
|
||
return msgobj, data
|
||
|
||
def _idempotent(self, msg, text):
|
||
eq = self.assertEquals
|
||
s = StringIO()
|
||
g = Generator(s, maxheaderlen=0)
|
||
g(msg)
|
||
eq(text, s.getvalue())
|
||
|
||
def test_parse_text_message(self):
|
||
eq = self.assertEquals
|
||
msg, text = self._msgobj('msg_01.txt')
|
||
eq(msg.get_type(), 'text/plain')
|
||
eq(msg.get_main_type(), 'text')
|
||
eq(msg.get_subtype(), 'plain')
|
||
eq(msg.get_params(), ['charset=us-ascii'])
|
||
eq(msg.get_param('charset'), 'us-ascii')
|
||
eq(msg.preamble, None)
|
||
eq(msg.epilogue, None)
|
||
self._idempotent(msg, text)
|
||
|
||
def test_parse_untyped_message(self):
|
||
eq = self.assertEquals
|
||
msg, text = self._msgobj('msg_03.txt')
|
||
eq(msg.get_type(), None)
|
||
eq(msg.get_params(), None)
|
||
eq(msg.get_param('charset'), None)
|
||
self._idempotent(msg, text)
|
||
|
||
def test_simple_multipart(self):
|
||
msg, text = self._msgobj('msg_04.txt')
|
||
self._idempotent(msg, text)
|
||
|
||
def test_MIME_digest(self):
|
||
msg, text = self._msgobj('msg_02.txt')
|
||
self._idempotent(msg, text)
|
||
|
||
def test_mixed_with_image(self):
|
||
msg, text = self._msgobj('msg_06.txt')
|
||
self._idempotent(msg, text)
|
||
|
||
def test_multipart_report(self):
|
||
msg, text = self._msgobj('msg_05.txt')
|
||
self._idempotent(msg, text)
|
||
|
||
def test_content_type(self):
|
||
eq = self.assertEquals
|
||
# Get a message object and reset the seek pointer for other tests
|
||
msg, text = self._msgobj('msg_05.txt')
|
||
eq(msg.get_type(), 'multipart/report')
|
||
# Test the Content-Type: parameters
|
||
params = {}
|
||
for p in msg.get_params():
|
||
pk, pv = p.split('=', 1)
|
||
params[pk] = pv
|
||
eq(params['report-type'], 'delivery-status')
|
||
eq(params['boundary'], '"D1690A7AC1.996856090/mail.example.com"')
|
||
eq(msg.preamble, 'This is a MIME-encapsulated message.\n\n')
|
||
eq(msg.epilogue, '\n\n')
|
||
eq(len(msg.get_payload()), 3)
|
||
# Make sure the subparts are what we expect
|
||
msg1 = msg.get_payload(0)
|
||
eq(msg1.get_type(), 'text/plain')
|
||
eq(msg1.get_payload(), 'Yadda yadda yadda\n')
|
||
msg2 = msg.get_payload(1)
|
||
eq(msg2.get_type(), None)
|
||
eq(msg2.get_payload(), 'Yadda yadda yadda\n')
|
||
msg3 = msg.get_payload(2)
|
||
eq(msg3.get_type(), 'message/rfc822')
|
||
self.failUnless(isinstance(msg3, Message))
|
||
msg4 = msg3.get_payload()
|
||
self.failUnless(isinstance(msg4, Message))
|
||
eq(msg4.get_payload(), 'Yadda yadda yadda\n')
|
||
|
||
def test_parser(self):
|
||
eq = self.assertEquals
|
||
msg, text = self._msgobj('msg_06.txt')
|
||
# Check some of the outer headers
|
||
eq(msg.get_type(), 'message/rfc822')
|
||
# Make sure there's exactly one thing in the payload and that's a
|
||
# sub-Message object of type text/plain
|
||
msg1 = msg.get_payload()
|
||
self.failUnless(isinstance(msg1, Message))
|
||
eq(msg1.get_type(), 'text/plain')
|
||
self.failUnless(isinstance(msg1.get_payload(), StringType))
|
||
eq(msg1.get_payload(), '\n')
|
||
|
||
|
||
|
||
class TestMiscellaneous(unittest.TestCase):
|
||
def test_message_from_string(self):
|
||
fp = openfile('msg_01.txt')
|
||
try:
|
||
text = fp.read()
|
||
finally:
|
||
fp.close()
|
||
msg = email.message_from_string(text)
|
||
s = StringIO()
|
||
# Don't wrap/continue long headers since we're trying to test
|
||
# idempotency.
|
||
g = Generator(s, maxheaderlen=0)
|
||
g(msg)
|
||
self.assertEqual(text, s.getvalue())
|
||
|
||
def test_message_from_file(self):
|
||
fp = openfile('msg_01.txt')
|
||
try:
|
||
text = fp.read()
|
||
fp.seek(0)
|
||
msg = email.message_from_file(fp)
|
||
s = StringIO()
|
||
# Don't wrap/continue long headers since we're trying to test
|
||
# idempotency.
|
||
g = Generator(s, maxheaderlen=0)
|
||
g(msg)
|
||
self.assertEqual(text, s.getvalue())
|
||
finally:
|
||
fp.close()
|
||
|
||
def test_message_from_string_with_class(self):
|
||
unless = self.failUnless
|
||
fp = openfile('msg_01.txt')
|
||
try:
|
||
text = fp.read()
|
||
finally:
|
||
fp.close()
|
||
# Create a subclass
|
||
class MyMessage(Message):
|
||
pass
|
||
|
||
msg = email.message_from_string(text, MyMessage)
|
||
unless(isinstance(msg, MyMessage))
|
||
# Try something more complicated
|
||
fp = openfile('msg_02.txt')
|
||
try:
|
||
text = fp.read()
|
||
finally:
|
||
fp.close()
|
||
msg = email.message_from_string(text, MyMessage)
|
||
for subpart in msg.walk():
|
||
unless(isinstance(subpart, MyMessage))
|
||
|
||
|
||
def test_message_from_file_with_class(self):
|
||
unless = self.failUnless
|
||
# Create a subclass
|
||
class MyMessage(Message):
|
||
pass
|
||
|
||
fp = openfile('msg_01.txt')
|
||
try:
|
||
msg = email.message_from_file(fp, MyMessage)
|
||
finally:
|
||
fp.close()
|
||
unless(isinstance(msg, MyMessage))
|
||
# Try something more complicated
|
||
fp = openfile('msg_02.txt')
|
||
try:
|
||
msg = email.message_from_file(fp, MyMessage)
|
||
finally:
|
||
fp.close()
|
||
for subpart in msg.walk():
|
||
unless(isinstance(subpart, MyMessage))
|
||
|
||
|
||
|
||
class TestIterators(TestEmailBase):
|
||
def test_body_line_iterator(self):
|
||
eq = self.assertEqual
|
||
# First a simple non-multipart message
|
||
msg = self._msgobj('msg_01.txt')
|
||
it = Iterators.body_line_iterator(msg)
|
||
lines = []
|
||
for line in it:
|
||
lines.append(line)
|
||
eq(len(lines), 6)
|
||
eq(EMPTYSTRING.join(lines), msg.get_payload())
|
||
# Now a more complicated multipart
|
||
msg = self._msgobj('msg_02.txt')
|
||
it = Iterators.body_line_iterator(msg)
|
||
lines = []
|
||
for line in it:
|
||
lines.append(line)
|
||
eq(len(lines), 43)
|
||
eq(EMPTYSTRING.join(lines), """\
|
||
Send Ppp mailing list submissions to
|
||
ppp@zzz.org
|
||
|
||
To subscribe or unsubscribe via the World Wide Web, visit
|
||
http://www.zzz.org/mailman/listinfo/ppp
|
||
or, via email, send a message with subject or body 'help' to
|
||
ppp-request@zzz.org
|
||
|
||
You can reach the person managing the list at
|
||
ppp-admin@zzz.org
|
||
|
||
When replying, please edit your Subject line so it is more specific
|
||
than "Re: Contents of Ppp digest..."
|
||
|
||
Today's Topics:
|
||
|
||
1. testing #1 (Barry A. Warsaw)
|
||
2. testing #2 (Barry A. Warsaw)
|
||
3. testing #3 (Barry A. Warsaw)
|
||
4. testing #4 (Barry A. Warsaw)
|
||
5. testing #5 (Barry A. Warsaw)
|
||
|
||
hello
|
||
|
||
|
||
hello
|
||
|
||
|
||
hello
|
||
|
||
|
||
hello
|
||
|
||
|
||
hello
|
||
|
||
|
||
|
||
_______________________________________________
|
||
Ppp mailing list
|
||
Ppp@zzz.org
|
||
http://www.zzz.org/mailman/listinfo/ppp
|
||
|
||
""")
|
||
|
||
def test_typed_subpart_iterator(self):
|
||
eq = self.assertEqual
|
||
msg = self._msgobj('msg_04.txt')
|
||
it = Iterators.typed_subpart_iterator(msg, 'text')
|
||
lines = []
|
||
subparts = 0
|
||
for subpart in it:
|
||
subparts += 1
|
||
lines.append(subpart.get_payload())
|
||
eq(subparts, 2)
|
||
eq(EMPTYSTRING.join(lines), """\
|
||
a simple kind of mirror
|
||
to reflect upon our own
|
||
a simple kind of mirror
|
||
to reflect upon our own
|
||
""")
|
||
|
||
|
||
|
||
def suite():
|
||
suite = unittest.TestSuite()
|
||
suite.addTest(unittest.makeSuite(TestMessageAPI))
|
||
suite.addTest(unittest.makeSuite(TestEncoders))
|
||
suite.addTest(unittest.makeSuite(TestLongHeaders))
|
||
suite.addTest(unittest.makeSuite(TestFromMangling))
|
||
suite.addTest(unittest.makeSuite(TestImage))
|
||
suite.addTest(unittest.makeSuite(TestText))
|
||
suite.addTest(unittest.makeSuite(TestMultipartMixed))
|
||
suite.addTest(unittest.makeSuite(TestNonConformant))
|
||
suite.addTest(unittest.makeSuite(TestRFC2047))
|
||
suite.addTest(unittest.makeSuite(TestMessageRFC822))
|
||
suite.addTest(unittest.makeSuite(TestIdempotent))
|
||
suite.addTest(unittest.makeSuite(TestMiscellaneous))
|
||
suite.addTest(unittest.makeSuite(TestIterators))
|
||
return suite
|
||
|
||
|
||
|
||
if __name__ == '__main__':
|
||
unittest.main(defaultTest='suite')
|
||
else:
|
||
from test_support import run_suite
|
||
run_suite(suite())
|