Python code coverage for Lib/email/test/test_email.py

#	count	content
1	n/a	# Copyright (C) 2001-2010 Python Software Foundation
2	n/a	# Contact: email-sig@python.org
3	n/a	# email package unit tests
4	n/a
5	n/a	import os
6	n/a	import re
7	n/a	import sys
8	n/a	import time
9	n/a	import base64
10	n/a	import difflib
11	n/a	import unittest
12	n/a	import warnings
13	n/a	import textwrap
14	n/a
15	n/a	from io import StringIO, BytesIO
16	n/a	from itertools import chain
17	n/a
18	n/a	import email
19	n/a
20	n/a	from email.charset import Charset
21	n/a	from email.header import Header, decode_header, make_header
22	n/a	from email.parser import Parser, HeaderParser
23	n/a	from email.generator import Generator, DecodedGenerator
24	n/a	from email.message import Message
25	n/a	from email.mime.application import MIMEApplication
26	n/a	from email.mime.audio import MIMEAudio
27	n/a	from email.mime.text import MIMEText
28	n/a	from email.mime.image import MIMEImage
29	n/a	from email.mime.base import MIMEBase
30	n/a	from email.mime.message import MIMEMessage
31	n/a	from email.mime.multipart import MIMEMultipart
32	n/a	from email import utils
33	n/a	from email import errors
34	n/a	from email import encoders
35	n/a	from email import iterators
36	n/a	from email import base64mime
37	n/a	from email import quoprimime
38	n/a
39	n/a	from test.support import findfile, run_unittest, unlink
40	n/a	from email.test import __file__ as landmark
41	n/a
42	n/a
43	n/a	NL = '\n'
44	n/a	EMPTYSTRING = ''
45	n/a	SPACE = ' '
46	n/a
47	n/a
48	n/a
49	n/a	def openfile(filename, args, *kws):
50	n/a	path = os.path.join(os.path.dirname(landmark), 'data', filename)
51	n/a	return open(path, args, *kws)
52	n/a
53	n/a
54	n/a
55	n/a	# Base test class
56	n/a	class TestEmailBase(unittest.TestCase):
57	n/a	def ndiffAssertEqual(self, first, second):
58	n/a	"""Like assertEqual except use ndiff for readable output."""
59	n/a	if first != second:
60	n/a	sfirst = str(first)
61	n/a	ssecond = str(second)
62	n/a	rfirst = [repr(line) for line in sfirst.splitlines()]
63	n/a	rsecond = [repr(line) for line in ssecond.splitlines()]
64	n/a	diff = difflib.ndiff(rfirst, rsecond)
65	n/a	raise self.failureException(NL + NL.join(diff))
66	n/a
67	n/a	def _msgobj(self, filename):
68	n/a	with openfile(findfile(filename)) as fp:
69	n/a	return email.message_from_file(fp)
70	n/a
71	n/a
72	n/a
73	n/a	# Test various aspects of the Message class's API
74	n/a	class TestMessageAPI(TestEmailBase):
75	n/a	def test_get_all(self):
76	n/a	eq = self.assertEqual
77	n/a	msg = self._msgobj('msg_20.txt')
78	n/a	eq(msg.get_all('cc'), ['ccc@zzz.org', 'ddd@zzz.org', 'eee@zzz.org'])
79	n/a	eq(msg.get_all('xx', 'n/a'), 'n/a')
80	n/a
81	n/a	def test_getset_charset(self):
82	n/a	eq = self.assertEqual
83	n/a	msg = Message()
84	n/a	eq(msg.get_charset(), None)
85	n/a	charset = Charset('iso-8859-1')
86	n/a	msg.set_charset(charset)
87	n/a	eq(msg['mime-version'], '1.0')
88	n/a	eq(msg.get_content_type(), 'text/plain')
89	n/a	eq(msg['content-type'], 'text/plain; charset="iso-8859-1"')
90	n/a	eq(msg.get_param('charset'), 'iso-8859-1')
91	n/a	eq(msg['content-transfer-encoding'], 'quoted-printable')
92	n/a	eq(msg.get_charset().input_charset, 'iso-8859-1')
93	n/a	# Remove the charset
94	n/a	msg.set_charset(None)
95	n/a	eq(msg.get_charset(), None)
96	n/a	eq(msg['content-type'], 'text/plain')
97	n/a	# Try adding a charset when there's already MIME headers present
98	n/a	msg = Message()
99	n/a	msg['MIME-Version'] = '2.0'
100	n/a	msg['Content-Type'] = 'text/x-weird'
101	n/a	msg['Content-Transfer-Encoding'] = 'quinted-puntable'
102	n/a	msg.set_charset(charset)
103	n/a	eq(msg['mime-version'], '2.0')
104	n/a	eq(msg['content-type'], 'text/x-weird; charset="iso-8859-1"')
105	n/a	eq(msg['content-transfer-encoding'], 'quinted-puntable')
106	n/a
107	n/a	def test_set_charset_from_string(self):
108	n/a	eq = self.assertEqual
109	n/a	msg = Message()
110	n/a	msg.set_charset('us-ascii')
111	n/a	eq(msg.get_charset().input_charset, 'us-ascii')
112	n/a	eq(msg['content-type'], 'text/plain; charset="us-ascii"')
113	n/a
114	n/a	def test_set_payload_with_charset(self):
115	n/a	msg = Message()
116	n/a	charset = Charset('iso-8859-1')
117	n/a	msg.set_payload('This is a string payload', charset)
118	n/a	self.assertEqual(msg.get_charset().input_charset, 'iso-8859-1')
119	n/a
120	n/a	def test_get_charsets(self):
121	n/a	eq = self.assertEqual
122	n/a
123	n/a	msg = self._msgobj('msg_08.txt')
124	n/a	charsets = msg.get_charsets()
125	n/a	eq(charsets, [None, 'us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])
126	n/a
127	n/a	msg = self._msgobj('msg_09.txt')
128	n/a	charsets = msg.get_charsets('dingbat')
129	n/a	eq(charsets, ['dingbat', 'us-ascii', 'iso-8859-1', 'dingbat',
130	n/a	'koi8-r'])
131	n/a
132	n/a	msg = self._msgobj('msg_12.txt')
133	n/a	charsets = msg.get_charsets()
134	n/a	eq(charsets, [None, 'us-ascii', 'iso-8859-1', None, 'iso-8859-2',
135	n/a	'iso-8859-3', 'us-ascii', 'koi8-r'])
136	n/a
137	n/a	def test_get_filename(self):
138	n/a	eq = self.assertEqual
139	n/a
140	n/a	msg = self._msgobj('msg_04.txt')
141	n/a	filenames = [p.get_filename() for p in msg.get_payload()]
142	n/a	eq(filenames, ['msg.txt', 'msg.txt'])
143	n/a
144	n/a	msg = self._msgobj('msg_07.txt')
145	n/a	subpart = msg.get_payload(1)
146	n/a	eq(subpart.get_filename(), 'dingusfish.gif')
147	n/a
148	n/a	def test_get_filename_with_name_parameter(self):
149	n/a	eq = self.assertEqual
150	n/a
151	n/a	msg = self._msgobj('msg_44.txt')
152	n/a	filenames = [p.get_filename() for p in msg.get_payload()]
153	n/a	eq(filenames, ['msg.txt', 'msg.txt'])
154	n/a
155	n/a	def test_get_boundary(self):
156	n/a	eq = self.assertEqual
157	n/a	msg = self._msgobj('msg_07.txt')
158	n/a	# No quotes!
159	n/a	eq(msg.get_boundary(), 'BOUNDARY')
160	n/a
161	n/a	def test_set_boundary(self):
162	n/a	eq = self.assertEqual
163	n/a	# This one has no existing boundary parameter, but the Content-Type:
164	n/a	# header appears fifth.
165	n/a	msg = self._msgobj('msg_01.txt')
166	n/a	msg.set_boundary('BOUNDARY')
167	n/a	header, value = msg.items()[4]
168	n/a	eq(header.lower(), 'content-type')
169	n/a	eq(value, 'text/plain; charset="us-ascii"; boundary="BOUNDARY"')
170	n/a	# This one has a Content-Type: header, with a boundary, stuck in the
171	n/a	# middle of its headers. Make sure the order is preserved; it should
172	n/a	# be fifth.
173	n/a	msg = self._msgobj('msg_04.txt')
174	n/a	msg.set_boundary('BOUNDARY')
175	n/a	header, value = msg.items()[4]
176	n/a	eq(header.lower(), 'content-type')
177	n/a	eq(value, 'multipart/mixed; boundary="BOUNDARY"')
178	n/a	# And this one has no Content-Type: header at all.
179	n/a	msg = self._msgobj('msg_03.txt')
180	n/a	self.assertRaises(errors.HeaderParseError,
181	n/a	msg.set_boundary, 'BOUNDARY')
182	n/a
183	n/a	def test_make_boundary(self):
184	n/a	msg = MIMEMultipart('form-data')
185	n/a	# Note that when the boundary gets created is an implementation
186	n/a	# detail and might change.
187	n/a	self.assertEqual(msg.items()[0][1], 'multipart/form-data')
188	n/a	# Trigger creation of boundary
189	n/a	msg.as_string()
190	n/a	self.assertEqual(msg.items()[0][1][:33],
191	n/a	'multipart/form-data; boundary="==')
192	n/a	# XXX: there ought to be tests of the uniqueness of the boundary, too.
193	n/a
194	n/a	def test_message_rfc822_only(self):
195	n/a	# Issue 7970: message/rfc822 not in multipart parsed by
196	n/a	# HeaderParser caused an exception when flattened.
197	n/a	with openfile(findfile('msg_46.txt')) as fp:
198	n/a	msgdata = fp.read()
199	n/a	parser = HeaderParser()
200	n/a	msg = parser.parsestr(msgdata)
201	n/a	out = StringIO()
202	n/a	gen = Generator(out, True, 0)
203	n/a	gen.flatten(msg, False)
204	n/a	self.assertEqual(out.getvalue(), msgdata)
205	n/a
206	n/a	def test_get_decoded_payload(self):
207	n/a	eq = self.assertEqual
208	n/a	msg = self._msgobj('msg_10.txt')
209	n/a	# The outer message is a multipart
210	n/a	eq(msg.get_payload(decode=True), None)
211	n/a	# Subpart 1 is 7bit encoded
212	n/a	eq(msg.get_payload(0).get_payload(decode=True),
213	n/a	b'This is a 7bit encoded message.\n')
214	n/a	# Subpart 2 is quopri
215	n/a	eq(msg.get_payload(1).get_payload(decode=True),
216	n/a	b'\xa1This is a Quoted Printable encoded message!\n')
217	n/a	# Subpart 3 is base64
218	n/a	eq(msg.get_payload(2).get_payload(decode=True),
219	n/a	b'This is a Base64 encoded message.')
220	n/a	# Subpart 4 is base64 with a trailing newline, which
221	n/a	# used to be stripped (issue 7143).
222	n/a	eq(msg.get_payload(3).get_payload(decode=True),
223	n/a	b'This is a Base64 encoded message.\n')
224	n/a	# Subpart 5 has no Content-Transfer-Encoding: header.
225	n/a	eq(msg.get_payload(4).get_payload(decode=True),
226	n/a	b'This has no Content-Transfer-Encoding: header.\n')
227	n/a
228	n/a	def test_get_decoded_uu_payload(self):
229	n/a	eq = self.assertEqual
230	n/a	msg = Message()
231	n/a	msg.set_payload('begin 666 -\n+:&5L;&\\@=V]R;&0 \n \nend\n')
232	n/a	for cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
233	n/a	msg['content-transfer-encoding'] = cte
234	n/a	eq(msg.get_payload(decode=True), b'hello world')
235	n/a	# Now try some bogus data
236	n/a	msg.set_payload('foo')
237	n/a	eq(msg.get_payload(decode=True), b'foo')
238	n/a
239	n/a	def test_decoded_generator(self):
240	n/a	eq = self.assertEqual
241	n/a	msg = self._msgobj('msg_07.txt')
242	n/a	with openfile('msg_17.txt') as fp:
243	n/a	text = fp.read()
244	n/a	s = StringIO()
245	n/a	g = DecodedGenerator(s)
246	n/a	g.flatten(msg)
247	n/a	eq(s.getvalue(), text)
248	n/a
249	n/a	def test__contains__(self):
250	n/a	msg = Message()
251	n/a	msg['From'] = 'Me'
252	n/a	msg['to'] = 'You'
253	n/a	# Check for case insensitivity
254	n/a	self.assertTrue('from' in msg)
255	n/a	self.assertTrue('From' in msg)
256	n/a	self.assertTrue('FROM' in msg)
257	n/a	self.assertTrue('to' in msg)
258	n/a	self.assertTrue('To' in msg)
259	n/a	self.assertTrue('TO' in msg)
260	n/a
261	n/a	def test_as_string(self):
262	n/a	eq = self.ndiffAssertEqual
263	n/a	msg = self._msgobj('msg_01.txt')
264	n/a	with openfile('msg_01.txt') as fp:
265	n/a	text = fp.read()
266	n/a	eq(text, str(msg))
267	n/a	fullrepr = msg.as_string(unixfrom=True)
268	n/a	lines = fullrepr.split('\n')
269	n/a	self.assertTrue(lines[0].startswith('From '))
270	n/a	eq(text, NL.join(lines[1:]))
271	n/a
272	n/a	def test_bad_param(self):
273	n/a	msg = email.message_from_string("Content-Type: blarg; baz; boo\n")
274	n/a	self.assertEqual(msg.get_param('baz'), '')
275	n/a
276	n/a	def test_missing_filename(self):
277	n/a	msg = email.message_from_string("From: foo\n")
278	n/a	self.assertEqual(msg.get_filename(), None)
279	n/a
280	n/a	def test_bogus_filename(self):
281	n/a	msg = email.message_from_string(
282	n/a	"Content-Disposition: blarg; filename\n")
283	n/a	self.assertEqual(msg.get_filename(), '')
284	n/a
285	n/a	def test_missing_boundary(self):
286	n/a	msg = email.message_from_string("From: foo\n")
287	n/a	self.assertEqual(msg.get_boundary(), None)
288	n/a
289	n/a	def test_get_params(self):
290	n/a	eq = self.assertEqual
291	n/a	msg = email.message_from_string(
292	n/a	'X-Header: foo=one; bar=two; baz=three\n')
293	n/a	eq(msg.get_params(header='x-header'),
294	n/a	[('foo', 'one'), ('bar', 'two'), ('baz', 'three')])
295	n/a	msg = email.message_from_string(
296	n/a	'X-Header: foo; bar=one; baz=two\n')
297	n/a	eq(msg.get_params(header='x-header'),
298	n/a	[('foo', ''), ('bar', 'one'), ('baz', 'two')])
299	n/a	eq(msg.get_params(), None)
300	n/a	msg = email.message_from_string(
301	n/a	'X-Header: foo; bar="one"; baz=two\n')
302	n/a	eq(msg.get_params(header='x-header'),
303	n/a	[('foo', ''), ('bar', 'one'), ('baz', 'two')])
304	n/a
305	n/a	def test_get_param_liberal(self):
306	n/a	msg = Message()
307	n/a	msg['Content-Type'] = 'Content-Type: Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"'
308	n/a	self.assertEqual(msg.get_param('boundary'), 'CPIMSSMTPC06p5f3tG')
309	n/a
310	n/a	def test_get_param(self):
311	n/a	eq = self.assertEqual
312	n/a	msg = email.message_from_string(
313	n/a	"X-Header: foo=one; bar=two; baz=three\n")
314	n/a	eq(msg.get_param('bar', header='x-header'), 'two')
315	n/a	eq(msg.get_param('quuz', header='x-header'), None)
316	n/a	eq(msg.get_param('quuz'), None)
317	n/a	msg = email.message_from_string(
318	n/a	'X-Header: foo; bar="one"; baz=two\n')
319	n/a	eq(msg.get_param('foo', header='x-header'), '')
320	n/a	eq(msg.get_param('bar', header='x-header'), 'one')
321	n/a	eq(msg.get_param('baz', header='x-header'), 'two')
322	n/a	# XXX: We are not RFC-2045 compliant! We cannot parse:
323	n/a	# msg["Content-Type"] = 'text/plain; weird="hey; dolly? [you] @ <\\"home\\">?"'
324	n/a	# msg.get_param("weird")
325	n/a	# yet.
326	n/a
327	n/a	def test_get_param_funky_continuation_lines(self):
328	n/a	msg = self._msgobj('msg_22.txt')
329	n/a	self.assertEqual(msg.get_payload(1).get_param('name'), 'wibble.JPG')
330	n/a
331	n/a	def test_get_param_with_semis_in_quotes(self):
332	n/a	msg = email.message_from_string(
333	n/a	'Content-Type: image/pjpeg; name="Jim&&Jill"\n')
334	n/a	self.assertEqual(msg.get_param('name'), 'Jim&&Jill')
335	n/a	self.assertEqual(msg.get_param('name', unquote=False),
336	n/a	'"Jim&&Jill"')
337	n/a
338	n/a	def test_get_param_with_quotes(self):
339	n/a	msg = email.message_from_string(
340	n/a	'Content-Type: foo; bar0="baz\\"foobar"; bar1="\\"baz"')
341	n/a	self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
342	n/a	msg = email.message_from_string(
343	n/a	"Content-Type: foo; bar0=\"baz\\\"foobar\"; bar1=\"\\\"baz\"")
344	n/a	self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
345	n/a
346	n/a	def test_field_containment(self):
347	n/a	unless = self.assertTrue
348	n/a	msg = email.message_from_string('Header: exists')
349	n/a	unless('header' in msg)
350	n/a	unless('Header' in msg)
351	n/a	unless('HEADER' in msg)
352	n/a	self.assertFalse('headerx' in msg)
353	n/a
354	n/a	def test_set_param(self):
355	n/a	eq = self.assertEqual
356	n/a	msg = Message()
357	n/a	msg.set_param('charset', 'iso-2022-jp')
358	n/a	eq(msg.get_param('charset'), 'iso-2022-jp')
359	n/a	msg.set_param('importance', 'high value')
360	n/a	eq(msg.get_param('importance'), 'high value')
361	n/a	eq(msg.get_param('importance', unquote=False), '"high value"')
362	n/a	eq(msg.get_params(), [('text/plain', ''),
363	n/a	('charset', 'iso-2022-jp'),
364	n/a	('importance', 'high value')])
365	n/a	eq(msg.get_params(unquote=False), [('text/plain', ''),
366	n/a	('charset', '"iso-2022-jp"'),
367	n/a	('importance', '"high value"')])
368	n/a	msg.set_param('charset', 'iso-9999-xx', header='X-Jimmy')
369	n/a	eq(msg.get_param('charset', header='X-Jimmy'), 'iso-9999-xx')
370	n/a
371	n/a	def test_del_param(self):
372	n/a	eq = self.assertEqual
373	n/a	msg = self._msgobj('msg_05.txt')
374	n/a	eq(msg.get_params(),
375	n/a	[('multipart/report', ''), ('report-type', 'delivery-status'),
376	n/a	('boundary', 'D1690A7AC1.996856090/mail.example.com')])
377	n/a	old_val = msg.get_param("report-type")
378	n/a	msg.del_param("report-type")
379	n/a	eq(msg.get_params(),
380	n/a	[('multipart/report', ''),
381	n/a	('boundary', 'D1690A7AC1.996856090/mail.example.com')])
382	n/a	msg.set_param("report-type", old_val)
383	n/a	eq(msg.get_params(),
384	n/a	[('multipart/report', ''),
385	n/a	('boundary', 'D1690A7AC1.996856090/mail.example.com'),
386	n/a	('report-type', old_val)])
387	n/a
388	n/a	def test_del_param_on_other_header(self):
389	n/a	msg = Message()
390	n/a	msg.add_header('Content-Disposition', 'attachment', filename='bud.gif')
391	n/a	msg.del_param('filename', 'content-disposition')
392	n/a	self.assertEqual(msg['content-disposition'], 'attachment')
393	n/a
394	n/a	def test_set_type(self):
395	n/a	eq = self.assertEqual
396	n/a	msg = Message()
397	n/a	self.assertRaises(ValueError, msg.set_type, 'text')
398	n/a	msg.set_type('text/plain')
399	n/a	eq(msg['content-type'], 'text/plain')
400	n/a	msg.set_param('charset', 'us-ascii')
401	n/a	eq(msg['content-type'], 'text/plain; charset="us-ascii"')
402	n/a	msg.set_type('text/html')
403	n/a	eq(msg['content-type'], 'text/html; charset="us-ascii"')
404	n/a
405	n/a	def test_set_type_on_other_header(self):
406	n/a	msg = Message()
407	n/a	msg['X-Content-Type'] = 'text/plain'
408	n/a	msg.set_type('application/octet-stream', 'X-Content-Type')
409	n/a	self.assertEqual(msg['x-content-type'], 'application/octet-stream')
410	n/a
411	n/a	def test_get_content_type_missing(self):
412	n/a	msg = Message()
413	n/a	self.assertEqual(msg.get_content_type(), 'text/plain')
414	n/a
415	n/a	def test_get_content_type_missing_with_default_type(self):
416	n/a	msg = Message()
417	n/a	msg.set_default_type('message/rfc822')
418	n/a	self.assertEqual(msg.get_content_type(), 'message/rfc822')
419	n/a
420	n/a	def test_get_content_type_from_message_implicit(self):
421	n/a	msg = self._msgobj('msg_30.txt')
422	n/a	self.assertEqual(msg.get_payload(0).get_content_type(),
423	n/a	'message/rfc822')
424	n/a
425	n/a	def test_get_content_type_from_message_explicit(self):
426	n/a	msg = self._msgobj('msg_28.txt')
427	n/a	self.assertEqual(msg.get_payload(0).get_content_type(),
428	n/a	'message/rfc822')
429	n/a
430	n/a	def test_get_content_type_from_message_text_plain_implicit(self):
431	n/a	msg = self._msgobj('msg_03.txt')
432	n/a	self.assertEqual(msg.get_content_type(), 'text/plain')
433	n/a
434	n/a	def test_get_content_type_from_message_text_plain_explicit(self):
435	n/a	msg = self._msgobj('msg_01.txt')
436	n/a	self.assertEqual(msg.get_content_type(), 'text/plain')
437	n/a
438	n/a	def test_get_content_maintype_missing(self):
439	n/a	msg = Message()
440	n/a	self.assertEqual(msg.get_content_maintype(), 'text')
441	n/a
442	n/a	def test_get_content_maintype_missing_with_default_type(self):
443	n/a	msg = Message()
444	n/a	msg.set_default_type('message/rfc822')
445	n/a	self.assertEqual(msg.get_content_maintype(), 'message')
446	n/a
447	n/a	def test_get_content_maintype_from_message_implicit(self):
448	n/a	msg = self._msgobj('msg_30.txt')
449	n/a	self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
450	n/a
451	n/a	def test_get_content_maintype_from_message_explicit(self):
452	n/a	msg = self._msgobj('msg_28.txt')
453	n/a	self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
454	n/a
455	n/a	def test_get_content_maintype_from_message_text_plain_implicit(self):
456	n/a	msg = self._msgobj('msg_03.txt')
457	n/a	self.assertEqual(msg.get_content_maintype(), 'text')
458	n/a
459	n/a	def test_get_content_maintype_from_message_text_plain_explicit(self):
460	n/a	msg = self._msgobj('msg_01.txt')
461	n/a	self.assertEqual(msg.get_content_maintype(), 'text')
462	n/a
463	n/a	def test_get_content_subtype_missing(self):
464	n/a	msg = Message()
465	n/a	self.assertEqual(msg.get_content_subtype(), 'plain')
466	n/a
467	n/a	def test_get_content_subtype_missing_with_default_type(self):
468	n/a	msg = Message()
469	n/a	msg.set_default_type('message/rfc822')
470	n/a	self.assertEqual(msg.get_content_subtype(), 'rfc822')
471	n/a
472	n/a	def test_get_content_subtype_from_message_implicit(self):
473	n/a	msg = self._msgobj('msg_30.txt')
474	n/a	self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
475	n/a
476	n/a	def test_get_content_subtype_from_message_explicit(self):
477	n/a	msg = self._msgobj('msg_28.txt')
478	n/a	self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
479	n/a
480	n/a	def test_get_content_subtype_from_message_text_plain_implicit(self):
481	n/a	msg = self._msgobj('msg_03.txt')
482	n/a	self.assertEqual(msg.get_content_subtype(), 'plain')
483	n/a
484	n/a	def test_get_content_subtype_from_message_text_plain_explicit(self):
485	n/a	msg = self._msgobj('msg_01.txt')
486	n/a	self.assertEqual(msg.get_content_subtype(), 'plain')
487	n/a
488	n/a	def test_get_content_maintype_error(self):
489	n/a	msg = Message()
490	n/a	msg['Content-Type'] = 'no-slash-in-this-string'
491	n/a	self.assertEqual(msg.get_content_maintype(), 'text')
492	n/a
493	n/a	def test_get_content_subtype_error(self):
494	n/a	msg = Message()
495	n/a	msg['Content-Type'] = 'no-slash-in-this-string'
496	n/a	self.assertEqual(msg.get_content_subtype(), 'plain')
497	n/a
498	n/a	def test_replace_header(self):
499	n/a	eq = self.assertEqual
500	n/a	msg = Message()
501	n/a	msg.add_header('First', 'One')
502	n/a	msg.add_header('Second', 'Two')
503	n/a	msg.add_header('Third', 'Three')
504	n/a	eq(msg.keys(), ['First', 'Second', 'Third'])
505	n/a	eq(msg.values(), ['One', 'Two', 'Three'])
506	n/a	msg.replace_header('Second', 'Twenty')
507	n/a	eq(msg.keys(), ['First', 'Second', 'Third'])
508	n/a	eq(msg.values(), ['One', 'Twenty', 'Three'])
509	n/a	msg.add_header('First', 'Eleven')
510	n/a	msg.replace_header('First', 'One Hundred')
511	n/a	eq(msg.keys(), ['First', 'Second', 'Third', 'First'])
512	n/a	eq(msg.values(), ['One Hundred', 'Twenty', 'Three', 'Eleven'])
513	n/a	self.assertRaises(KeyError, msg.replace_header, 'Fourth', 'Missing')
514	n/a
515	n/a	def test_broken_base64_payload(self):
516	n/a	x = 'AwDp0P7//y6LwKEAcPa/6Q=9'
517	n/a	msg = Message()
518	n/a	msg['content-type'] = 'audio/x-midi'
519	n/a	msg['content-transfer-encoding'] = 'base64'
520	n/a	msg.set_payload(x)
521	n/a	self.assertEqual(msg.get_payload(decode=True),
522	n/a	bytes(x, 'raw-unicode-escape'))
523	n/a
524	n/a	# Issue 1078919
525	n/a	def test_ascii_add_header(self):
526	n/a	msg = Message()
527	n/a	msg.add_header('Content-Disposition', 'attachment',
528	n/a	filename='bud.gif')
529	n/a	self.assertEqual('attachment; filename="bud.gif"',
530	n/a	msg['Content-Disposition'])
531	n/a
532	n/a	def test_noascii_add_header(self):
533	n/a	msg = Message()
534	n/a	msg.add_header('Content-Disposition', 'attachment',
535	n/a	filename="FuÃŸballer.ppt")
536	n/a	self.assertEqual(
537	n/a	'attachment; filename*=utf-8\'\'Fu%C3%9Fballer.ppt',
538	n/a	msg['Content-Disposition'])
539	n/a
540	n/a	def test_nonascii_add_header_via_triple(self):
541	n/a	msg = Message()
542	n/a	msg.add_header('Content-Disposition', 'attachment',
543	n/a	filename=('iso-8859-1', '', 'FuÃŸballer.ppt'))
544	n/a	self.assertEqual(
545	n/a	'attachment; filename*=iso-8859-1\'\'Fu%DFballer.ppt',
546	n/a	msg['Content-Disposition'])
547	n/a
548	n/a	def test_ascii_add_header_with_tspecial(self):
549	n/a	msg = Message()
550	n/a	msg.add_header('Content-Disposition', 'attachment',
551	n/a	filename="windows [filename].ppt")
552	n/a	self.assertEqual(
553	n/a	'attachment; filename="windows [filename].ppt"',
554	n/a	msg['Content-Disposition'])
555	n/a
556	n/a	def test_nonascii_add_header_with_tspecial(self):
557	n/a	msg = Message()
558	n/a	msg.add_header('Content-Disposition', 'attachment',
559	n/a	filename="FuÃŸballer [filename].ppt")
560	n/a	self.assertEqual(
561	n/a	"attachment; filename*=utf-8''Fu%C3%9Fballer%20%5Bfilename%5D.ppt",
562	n/a	msg['Content-Disposition'])
563	n/a
564	n/a	# Issue 5871: reject an attempt to embed a header inside a header value
565	n/a	# (header injection attack).
566	n/a	def test_embeded_header_via_Header_rejected(self):
567	n/a	msg = Message()
568	n/a	msg['Dummy'] = Header('dummy\nX-Injected-Header: test')
569	n/a	self.assertRaises(errors.HeaderParseError, msg.as_string)
570	n/a
571	n/a	def test_embeded_header_via_string_rejected(self):
572	n/a	msg = Message()
573	n/a	msg['Dummy'] = 'dummy\nX-Injected-Header: test'
574	n/a	self.assertRaises(errors.HeaderParseError, msg.as_string)
575	n/a
576	n/a
577	n/a	# Test the email.encoders module
578	n/a	class TestEncoders(unittest.TestCase):
579	n/a	def test_encode_empty_payload(self):
580	n/a	eq = self.assertEqual
581	n/a	msg = Message()
582	n/a	msg.set_charset('us-ascii')
583	n/a	eq(msg['content-transfer-encoding'], '7bit')
584	n/a
585	n/a	def test_default_cte(self):
586	n/a	eq = self.assertEqual
587	n/a	# 7bit data and the default us-ascii _charset
588	n/a	msg = MIMEText('hello world')
589	n/a	eq(msg['content-transfer-encoding'], '7bit')
590	n/a	# Similar, but with 8bit data
591	n/a	msg = MIMEText('hello \xf8 world')
592	n/a	eq(msg['content-transfer-encoding'], '8bit')
593	n/a	# And now with a different charset
594	n/a	msg = MIMEText('hello \xf8 world', _charset='iso-8859-1')
595	n/a	eq(msg['content-transfer-encoding'], 'quoted-printable')
596	n/a
597	n/a	def test_encode7or8bit(self):
598	n/a	# Make sure a charset whose input character set is 8bit but
599	n/a	# whose output character set is 7bit gets a transfer-encoding
600	n/a	# of 7bit.
601	n/a	eq = self.assertEqual
602	n/a	msg = MIMEText('æ–‡', _charset='euc-jp')
603	n/a	eq(msg['content-transfer-encoding'], '7bit')
604	n/a
605	n/a
606	n/a	# Test long header wrapping
607	n/a	class TestLongHeaders(TestEmailBase):
608	n/a	def test_split_long_continuation(self):
609	n/a	eq = self.ndiffAssertEqual
610	n/a	msg = email.message_from_string("""\
611	n/a	Subject: bug demonstration
612	n/a	\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
613	n/a	\tmore text
614	n/a
615	n/a	test
616	n/a	""")
617	n/a	sfp = StringIO()
618	n/a	g = Generator(sfp)
619	n/a	g.flatten(msg)
620	n/a	eq(sfp.getvalue(), """\
621	n/a	Subject: bug demonstration
622	n/a	\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
623	n/a	\tmore text
624	n/a
625	n/a	test
626	n/a	""")
627	n/a
628	n/a	def test_another_long_almost_unsplittable_header(self):
629	n/a	eq = self.ndiffAssertEqual
630	n/a	hstr = """\
631	n/a	bug demonstration
632	n/a	\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
633	n/a	\tmore text"""
634	n/a	h = Header(hstr, continuation_ws='\t')
635	n/a	eq(h.encode(), """\
636	n/a	bug demonstration
637	n/a	\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
638	n/a	\tmore text""")
639	n/a	h = Header(hstr.replace('\t', ' '))
640	n/a	eq(h.encode(), """\
641	n/a	bug demonstration
642	n/a	12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
643	n/a	more text""")
644	n/a
645	n/a	def test_long_nonstring(self):
646	n/a	eq = self.ndiffAssertEqual
647	n/a	g = Charset("iso-8859-1")
648	n/a	cz = Charset("iso-8859-2")
649	n/a	utf8 = Charset("utf-8")
650	n/a	g_head = (b'Die Mieter treten hier ein werden mit einem Foerderband '
651	n/a	b'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '
652	n/a	b'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '
653	n/a	b'bef\xf6rdert. ')
654	n/a	cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '
655	n/a	b'd\xf9vtipu.. ')
656	n/a	utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
657	n/a	'\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
658	n/a	'\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
659	n/a	'\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
660	n/a	'\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '
661	n/a	'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '
662	n/a	'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'
663	n/a	'\u3044\u307e\u3059\u3002')
664	n/a	h = Header(g_head, g, header_name='Subject')
665	n/a	h.append(cz_head, cz)
666	n/a	h.append(utf8_head, utf8)
667	n/a	msg = Message()
668	n/a	msg['Subject'] = h
669	n/a	sfp = StringIO()
670	n/a	g = Generator(sfp)
671	n/a	g.flatten(msg)
672	n/a	eq(sfp.getvalue(), """\
673	n/a	Subject: =?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderb?=
674	n/a	=?iso-8859-1?q?and_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen?=
675	n/a	=?iso-8859-1?q?_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef?=
676	n/a	=?iso-8859-1?q?=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hrouti?=
677	n/a	=?iso-8859-2?q?ly_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=
678	n/a	=?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC5LiA?=
679	n/a	=?utf-8?b?6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn44Gf44KJ?=
680	n/a	=?utf-8?b?44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFzIE51bnN0dWNr?=
681	n/a	=?utf-8?b?IGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWloZXJodW5kIGRhcyBPZGVyIGRp?=
682	n/a	=?utf-8?b?ZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI3jgajoqIDjgaPjgabjgYTjgb7jgZk=?=
683	n/a	=?utf-8?b?44CC?=
684	n/a
685	n/a	""")
686	n/a	eq(h.encode(maxlinelen=76), """\
687	n/a	=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerde?=
688	n/a	=?iso-8859-1?q?rband_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndis?=
689	n/a	=?iso-8859-1?q?chen_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klinge?=
690	n/a	=?iso-8859-1?q?n_bef=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se?=
691	n/a	=?iso-8859-2?q?_hroutily_pod_tlakem_jejich_d=F9vtipu=2E=2E_?=
692	n/a	=?utf-8?b?5q2j56K644Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb?=
693	n/a	=?utf-8?b?44KT44CC5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go?=
694	n/a	=?utf-8?b?44Gv44Gn44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBp?=
695	n/a	=?utf-8?b?c3QgZGFzIE51bnN0dWNrIGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWlo?=
696	n/a	=?utf-8?b?ZXJodW5kIGRhcyBPZGVyIGRpZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI0=?=
697	n/a	=?utf-8?b?44Go6KiA44Gj44Gm44GE44G+44GZ44CC?=""")
698	n/a
699	n/a	def test_long_header_encode(self):
700	n/a	eq = self.ndiffAssertEqual
701	n/a	h = Header('wasnipoop; giraffes="very-long-necked-animals"; '
702	n/a	'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
703	n/a	header_name='X-Foobar-Spoink-Defrobnit')
704	n/a	eq(h.encode(), '''\
705	n/a	wasnipoop; giraffes="very-long-necked-animals";
706	n/a	spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
707	n/a
708	n/a	def test_long_header_encode_with_tab_continuation_is_just_a_hint(self):
709	n/a	eq = self.ndiffAssertEqual
710	n/a	h = Header('wasnipoop; giraffes="very-long-necked-animals"; '
711	n/a	'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
712	n/a	header_name='X-Foobar-Spoink-Defrobnit',
713	n/a	continuation_ws='\t')
714	n/a	eq(h.encode(), '''\
715	n/a	wasnipoop; giraffes="very-long-necked-animals";
716	n/a	spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
717	n/a
718	n/a	def test_long_header_encode_with_tab_continuation(self):
719	n/a	eq = self.ndiffAssertEqual
720	n/a	h = Header('wasnipoop; giraffes="very-long-necked-animals";\t'
721	n/a	'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
722	n/a	header_name='X-Foobar-Spoink-Defrobnit',
723	n/a	continuation_ws='\t')
724	n/a	eq(h.encode(), '''\
725	n/a	wasnipoop; giraffes="very-long-necked-animals";
726	n/a	\tspooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
727	n/a
728	n/a	def test_header_splitter(self):
729	n/a	eq = self.ndiffAssertEqual
730	n/a	msg = MIMEText('')
731	n/a	# It'd be great if we could use add_header() here, but that doesn't
732	n/a	# guarantee an order of the parameters.
733	n/a	msg['X-Foobar-Spoink-Defrobnit'] = (
734	n/a	'wasnipoop; giraffes="very-long-necked-animals"; '
735	n/a	'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"')
736	n/a	sfp = StringIO()
737	n/a	g = Generator(sfp)
738	n/a	g.flatten(msg)
739	n/a	eq(sfp.getvalue(), '''\
740	n/a	Content-Type: text/plain; charset="us-ascii"
741	n/a	MIME-Version: 1.0
742	n/a	Content-Transfer-Encoding: 7bit
743	n/a	X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
744	n/a	spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
745	n/a
746	n/a	''')
747	n/a
748	n/a	def test_no_semis_header_splitter(self):
749	n/a	eq = self.ndiffAssertEqual
750	n/a	msg = Message()
751	n/a	msg['From'] = 'test@dom.ain'
752	n/a	msg['References'] = SPACE.join('<%d@dom.ain>' % i for i in range(10))
753	n/a	msg.set_payload('Test')
754	n/a	sfp = StringIO()
755	n/a	g = Generator(sfp)
756	n/a	g.flatten(msg)
757	n/a	eq(sfp.getvalue(), """\
758	n/a	From: test@dom.ain
759	n/a	References: <0@dom.ain> <1@dom.ain> <2@dom.ain> <3@dom.ain> <4@dom.ain>
760	n/a	<5@dom.ain> <6@dom.ain> <7@dom.ain> <8@dom.ain> <9@dom.ain>
761	n/a
762	n/a	Test""")
763	n/a
764	n/a	def test_no_split_long_header(self):
765	n/a	eq = self.ndiffAssertEqual
766	n/a	hstr = 'References: ' + 'x' * 80
767	n/a	h = Header(hstr)
768	n/a	# These come on two lines because Headers are really field value
769	n/a	# classes and don't really know about their field names.
770	n/a	eq(h.encode(), """\
771	n/a	References:
772	n/a	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx""")
773	n/a	h = Header('x' * 80)
774	n/a	eq(h.encode(), 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
775	n/a
776	n/a	def test_splitting_multiple_long_lines(self):
777	n/a	eq = self.ndiffAssertEqual
778	n/a	hstr = """\
779	n/a	from babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
780	n/a	\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
781	n/a	\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
782	n/a	"""
783	n/a	h = Header(hstr, continuation_ws='\t')
784	n/a	eq(h.encode(), """\
785	n/a	from babylon.socal-raves.org (localhost [127.0.0.1]);
786	n/a	by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
787	n/a	for <mailman-admin@babylon.socal-raves.org>;
788	n/a	Sat, 2 Feb 2002 17:00:06 -0800 (PST)
789	n/a	\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);
790	n/a	by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
791	n/a	for <mailman-admin@babylon.socal-raves.org>;
792	n/a	Sat, 2 Feb 2002 17:00:06 -0800 (PST)
793	n/a	\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);
794	n/a	by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
795	n/a	for <mailman-admin@babylon.socal-raves.org>;
796	n/a	Sat, 2 Feb 2002 17:00:06 -0800 (PST)""")
797	n/a
798	n/a	def test_splitting_first_line_only_is_long(self):
799	n/a	eq = self.ndiffAssertEqual
800	n/a	hstr = """\
801	n/a	from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93] helo=cthulhu.gerg.ca)
802	n/a	\tby kronos.mems-exchange.org with esmtp (Exim 4.05)
803	n/a	\tid 17k4h5-00034i-00
804	n/a	\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400"""
805	n/a	h = Header(hstr, maxlinelen=78, header_name='Received',
806	n/a	continuation_ws='\t')
807	n/a	eq(h.encode(), """\
808	n/a	from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93]
809	n/a	helo=cthulhu.gerg.ca)
810	n/a	\tby kronos.mems-exchange.org with esmtp (Exim 4.05)
811	n/a	\tid 17k4h5-00034i-00
812	n/a	\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400""")
813	n/a
814	n/a	def test_long_8bit_header(self):
815	n/a	eq = self.ndiffAssertEqual
816	n/a	msg = Message()
817	n/a	h = Header('Britische Regierung gibt', 'iso-8859-1',
818	n/a	header_name='Subject')
819	n/a	h.append('gr\xfcnes Licht f\xfcr Offshore-Windkraftprojekte')
820	n/a	eq(h.encode(maxlinelen=76), """\
821	n/a	=?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offs?=
822	n/a	=?iso-8859-1?q?hore-Windkraftprojekte?=""")
823	n/a	msg['Subject'] = h
824	n/a	eq(msg.as_string(maxheaderlen=76), """\
825	n/a	Subject: =?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offs?=
826	n/a	=?iso-8859-1?q?hore-Windkraftprojekte?=
827	n/a
828	n/a	""")
829	n/a	eq(msg.as_string(maxheaderlen=0), """\
830	n/a	Subject: =?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offshore-Windkraftprojekte?=
831	n/a
832	n/a	""")
833	n/a
834	n/a	def test_long_8bit_header_no_charset(self):
835	n/a	eq = self.ndiffAssertEqual
836	n/a	msg = Message()
837	n/a	header_string = ('Britische Regierung gibt gr\xfcnes Licht '
838	n/a	'f\xfcr Offshore-Windkraftprojekte '
839	n/a	'<a-very-long-address@example.com>')
840	n/a	msg['Reply-To'] = header_string
841	n/a	self.assertRaises(UnicodeEncodeError, msg.as_string)
842	n/a	msg = Message()
843	n/a	msg['Reply-To'] = Header(header_string, 'utf-8',
844	n/a	header_name='Reply-To')
845	n/a	eq(msg.as_string(maxheaderlen=78), """\
846	n/a	Reply-To: =?utf-8?q?Britische_Regierung_gibt_gr=C3=BCnes_Licht_f=C3=BCr_Offs?=
847	n/a	=?utf-8?q?hore-Windkraftprojekte_=3Ca-very-long-address=40example=2Ecom=3E?=
848	n/a
849	n/a	""")
850	n/a
851	n/a	def test_long_to_header(self):
852	n/a	eq = self.ndiffAssertEqual
853	n/a	to = ('"Someone Test #A" <someone@eecs.umich.edu>,'
854	n/a	'<someone@eecs.umich.edu>,'
855	n/a	'"Someone Test #B" <someone@umich.edu>, '
856	n/a	'"Someone Test #C" <someone@eecs.umich.edu>, '
857	n/a	'"Someone Test #D" <someone@eecs.umich.edu>')
858	n/a	msg = Message()
859	n/a	msg['To'] = to
860	n/a	eq(msg.as_string(maxheaderlen=78), '''\
861	n/a	To: "Someone Test #A" <someone@eecs.umich.edu>,<someone@eecs.umich.edu>,
862	n/a	"Someone Test #B" <someone@umich.edu>,
863	n/a	"Someone Test #C" <someone@eecs.umich.edu>,
864	n/a	"Someone Test #D" <someone@eecs.umich.edu>
865	n/a
866	n/a	''')
867	n/a
868	n/a	def test_long_line_after_append(self):
869	n/a	eq = self.ndiffAssertEqual
870	n/a	s = 'This is an example of string which has almost the limit of header length.'
871	n/a	h = Header(s)
872	n/a	h.append('Add another line.')
873	n/a	eq(h.encode(maxlinelen=76), """\
874	n/a	This is an example of string which has almost the limit of header length.
875	n/a	Add another line.""")
876	n/a
877	n/a	def test_shorter_line_with_append(self):
878	n/a	eq = self.ndiffAssertEqual
879	n/a	s = 'This is a shorter line.'
880	n/a	h = Header(s)
881	n/a	h.append('Add another sentence. (Surprise?)')
882	n/a	eq(h.encode(),
883	n/a	'This is a shorter line. Add another sentence. (Surprise?)')
884	n/a
885	n/a	def test_long_field_name(self):
886	n/a	eq = self.ndiffAssertEqual
887	n/a	fn = 'X-Very-Very-Very-Long-Header-Name'
888	n/a	gs = ('Die Mieter treten hier ein werden mit einem Foerderband '
889	n/a	'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '
890	n/a	'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '
891	n/a	'bef\xf6rdert. ')
892	n/a	h = Header(gs, 'iso-8859-1', header_name=fn)
893	n/a	# BAW: this seems broken because the first line is too long
894	n/a	eq(h.encode(maxlinelen=76), """\
895	n/a	=?iso-8859-1?q?Die_Mieter_treten_hier_e?=
896	n/a	=?iso-8859-1?q?in_werden_mit_einem_Foerderband_komfortabel_den_Korridor_e?=
897	n/a	=?iso-8859-1?q?ntlang=2C_an_s=FCdl=FCndischen_Wandgem=E4lden_vorbei=2C_ge?=
898	n/a	=?iso-8859-1?q?gen_die_rotierenden_Klingen_bef=F6rdert=2E_?=""")
899	n/a
900	n/a	def test_long_received_header(self):
901	n/a	h = ('from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) '
902	n/a	'by hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP; '
903	n/a	'Wed, 05 Mar 2003 18:10:18 -0700')
904	n/a	msg = Message()
905	n/a	msg['Received-1'] = Header(h, continuation_ws='\t')
906	n/a	msg['Received-2'] = h
907	n/a	# This should be splitting on spaces not semicolons.
908	n/a	self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
909	n/a	Received-1: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;
910	n/a	Wed, 05 Mar 2003 18:10:18 -0700
911	n/a	Received-2: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;
912	n/a	Wed, 05 Mar 2003 18:10:18 -0700
913	n/a
914	n/a	""")
915	n/a
916	n/a	def test_string_headerinst_eq(self):
917	n/a	h = ('<15975.17901.207240.414604@sgigritzmann1.mathematik.'
918	n/a	'tu-muenchen.de> (David Bremner\'s message of '
919	n/a	'"Thu, 6 Mar 2003 13:58:21 +0100")')
920	n/a	msg = Message()
921	n/a	msg['Received-1'] = Header(h, header_name='Received-1',
922	n/a	continuation_ws='\t')
923	n/a	msg['Received-2'] = h
924	n/a	# XXX This should be splitting on spaces not commas.
925	n/a	self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
926	n/a	Received-1: <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David Bremner's message of \"Thu,
927	n/a	6 Mar 2003 13:58:21 +0100\")
928	n/a	Received-2: <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David Bremner's message of \"Thu,
929	n/a	6 Mar 2003 13:58:21 +0100\")
930	n/a
931	n/a	""")
932	n/a
933	n/a	def test_long_unbreakable_lines_with_continuation(self):
934	n/a	eq = self.ndiffAssertEqual
935	n/a	msg = Message()
936	n/a	t = """\
937	n/a	iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
938	n/a	locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp"""
939	n/a	msg['Face-1'] = t
940	n/a	msg['Face-2'] = Header(t, header_name='Face-2')
941	n/a	# XXX This splitting is all wrong. It the first value line should be
942	n/a	# snug against the field name.
943	n/a	eq(msg.as_string(maxheaderlen=78), """\
944	n/a	Face-1:\x20
945	n/a	iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
946	n/a	locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
947	n/a	Face-2:\x20
948	n/a	iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
949	n/a	locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
950	n/a
951	n/a	""")
952	n/a
953	n/a	def test_another_long_multiline_header(self):
954	n/a	eq = self.ndiffAssertEqual
955	n/a	m = ('Received: from siimage.com '
956	n/a	'([172.25.1.3]) by zima.siliconimage.com with '
957	n/a	'Microsoft SMTPSVC(5.0.2195.4905); '
958	n/a	'Wed, 16 Oct 2002 07:41:11 -0700')
959	n/a	msg = email.message_from_string(m)
960	n/a	eq(msg.as_string(maxheaderlen=78), '''\
961	n/a	Received: from siimage.com ([172.25.1.3]) by zima.siliconimage.com with Microsoft SMTPSVC(5.0.2195.4905);
962	n/a	Wed, 16 Oct 2002 07:41:11 -0700
963	n/a
964	n/a	''')
965	n/a
966	n/a	def test_long_lines_with_different_header(self):
967	n/a	eq = self.ndiffAssertEqual
968	n/a	h = ('List-Unsubscribe: '
969	n/a	'<http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,'
970	n/a	' <mailto:spamassassin-talk-request@lists.sourceforge.net'
971	n/a	'?subject=unsubscribe>')
972	n/a	msg = Message()
973	n/a	msg['List'] = h
974	n/a	msg['List'] = Header(h, header_name='List')
975	n/a	eq(msg.as_string(maxheaderlen=78), """\
976	n/a	List: List-Unsubscribe: <http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,
977	n/a	<mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>
978	n/a	List: List-Unsubscribe: <http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,
979	n/a	<mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>
980	n/a
981	n/a	""")
982	n/a
983	n/a	def test_long_rfc2047_header_with_embedded_fws(self):
984	n/a	h = Header(textwrap.dedent("""\
985	n/a	We're going to pretend this header is in a non-ascii character set
986	n/a	\tto see if line wrapping with encoded words and embedded
987	n/a	folding white space works"""),
988	n/a	charset='utf-8',
989	n/a	header_name='Test')
990	n/a	self.assertEqual(h.encode()+'\n', textwrap.dedent("""\
991	n/a	=?utf-8?q?We=27re_going_to_pretend_this_header_is_in_a_non-ascii_chara?=
992	n/a	=?utf-8?q?cter_set?=
993	n/a	=?utf-8?q?_to_see_if_line_wrapping_with_encoded_words_and_embedded?=
994	n/a	=?utf-8?q?_folding_white_space_works?=""")+'\n')
995	n/a
996	n/a
997	n/a
998	n/a	# Test mangling of "From " lines in the body of a message
999	n/a	class TestFromMangling(unittest.TestCase):
1000	n/a	def setUp(self):
1001	n/a	self.msg = Message()
1002	n/a	self.msg['From'] = 'aaa@bbb.org'
1003	n/a	self.msg.set_payload("""\
1004	n/a	From the desk of A.A.A.:
1005	n/a	Blah blah blah
1006	n/a	""")
1007	n/a
1008	n/a	def test_mangled_from(self):
1009	n/a	s = StringIO()
1010	n/a	g = Generator(s, mangle_from_=True)
1011	n/a	g.flatten(self.msg)
1012	n/a	self.assertEqual(s.getvalue(), """\
1013	n/a	From: aaa@bbb.org
1014	n/a
1015	n/a	>From the desk of A.A.A.:
1016	n/a	Blah blah blah
1017	n/a	""")
1018	n/a
1019	n/a	def test_dont_mangle_from(self):
1020	n/a	s = StringIO()
1021	n/a	g = Generator(s, mangle_from_=False)
1022	n/a	g.flatten(self.msg)
1023	n/a	self.assertEqual(s.getvalue(), """\
1024	n/a	From: aaa@bbb.org
1025	n/a
1026	n/a	From the desk of A.A.A.:
1027	n/a	Blah blah blah
1028	n/a	""")
1029	n/a
1030	n/a
1031	n/a
1032	n/a	# Test the basic MIMEAudio class
1033	n/a	class TestMIMEAudio(unittest.TestCase):
1034	n/a	def setUp(self):
1035	n/a	# Make sure we pick up the audiotest.au that lives in email/test/data.
1036	n/a	# In Python, there's an audiotest.au living in Lib/test but that isn't
1037	n/a	# included in some binary distros that don't include the test
1038	n/a	# package. The trailing empty string on the .join() is significant
1039	n/a	# since findfile() will do a dirname().
1040	n/a	datadir = os.path.join(os.path.dirname(landmark), 'data', '')
1041	n/a	with open(findfile('audiotest.au', datadir), 'rb') as fp:
1042	n/a	self._audiodata = fp.read()
1043	n/a	self._au = MIMEAudio(self._audiodata)
1044	n/a
1045	n/a	def test_guess_minor_type(self):
1046	n/a	self.assertEqual(self._au.get_content_type(), 'audio/basic')
1047	n/a
1048	n/a	def test_encoding(self):
1049	n/a	payload = self._au.get_payload()
1050	n/a	self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
1051	n/a	self._audiodata)
1052	n/a
1053	n/a	def test_checkSetMinor(self):
1054	n/a	au = MIMEAudio(self._audiodata, 'fish')
1055	n/a	self.assertEqual(au.get_content_type(), 'audio/fish')
1056	n/a
1057	n/a	def test_add_header(self):
1058	n/a	eq = self.assertEqual
1059	n/a	unless = self.assertTrue
1060	n/a	self._au.add_header('Content-Disposition', 'attachment',
1061	n/a	filename='audiotest.au')
1062	n/a	eq(self._au['content-disposition'],
1063	n/a	'attachment; filename="audiotest.au"')
1064	n/a	eq(self._au.get_params(header='content-disposition'),
1065	n/a	[('attachment', ''), ('filename', 'audiotest.au')])
1066	n/a	eq(self._au.get_param('filename', header='content-disposition'),
1067	n/a	'audiotest.au')
1068	n/a	missing = []
1069	n/a	eq(self._au.get_param('attachment', header='content-disposition'), '')
1070	n/a	unless(self._au.get_param('foo', failobj=missing,
1071	n/a	header='content-disposition') is missing)
1072	n/a	# Try some missing stuff
1073	n/a	unless(self._au.get_param('foobar', missing) is missing)
1074	n/a	unless(self._au.get_param('attachment', missing,
1075	n/a	header='foobar') is missing)
1076	n/a
1077	n/a
1078	n/a
1079	n/a	# Test the basic MIMEImage class
1080	n/a	class TestMIMEImage(unittest.TestCase):
1081	n/a	def setUp(self):
1082	n/a	with openfile('PyBanner048.gif', 'rb') as fp:
1083	n/a	self._imgdata = fp.read()
1084	n/a	self._im = MIMEImage(self._imgdata)
1085	n/a
1086	n/a	def test_guess_minor_type(self):
1087	n/a	self.assertEqual(self._im.get_content_type(), 'image/gif')
1088	n/a
1089	n/a	def test_encoding(self):
1090	n/a	payload = self._im.get_payload()
1091	n/a	self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
1092	n/a	self._imgdata)
1093	n/a
1094	n/a	def test_checkSetMinor(self):
1095	n/a	im = MIMEImage(self._imgdata, 'fish')
1096	n/a	self.assertEqual(im.get_content_type(), 'image/fish')
1097	n/a
1098	n/a	def test_add_header(self):
1099	n/a	eq = self.assertEqual
1100	n/a	unless = self.assertTrue
1101	n/a	self._im.add_header('Content-Disposition', 'attachment',
1102	n/a	filename='dingusfish.gif')
1103	n/a	eq(self._im['content-disposition'],
1104	n/a	'attachment; filename="dingusfish.gif"')
1105	n/a	eq(self._im.get_params(header='content-disposition'),
1106	n/a	[('attachment', ''), ('filename', 'dingusfish.gif')])
1107	n/a	eq(self._im.get_param('filename', header='content-disposition'),
1108	n/a	'dingusfish.gif')
1109	n/a	missing = []
1110	n/a	eq(self._im.get_param('attachment', header='content-disposition'), '')
1111	n/a	unless(self._im.get_param('foo', failobj=missing,
1112	n/a	header='content-disposition') is missing)
1113	n/a	# Try some missing stuff
1114	n/a	unless(self._im.get_param('foobar', missing) is missing)
1115	n/a	unless(self._im.get_param('attachment', missing,
1116	n/a	header='foobar') is missing)
1117	n/a
1118	n/a
1119	n/a
1120	n/a	# Test the basic MIMEApplication class
1121	n/a	class TestMIMEApplication(unittest.TestCase):
1122	n/a	def test_headers(self):
1123	n/a	eq = self.assertEqual
1124	n/a	msg = MIMEApplication(b'\xfa\xfb\xfc\xfd\xfe\xff')
1125	n/a	eq(msg.get_content_type(), 'application/octet-stream')
1126	n/a	eq(msg['content-transfer-encoding'], 'base64')
1127	n/a
1128	n/a	def test_body(self):
1129	n/a	eq = self.assertEqual
1130	n/a	bytes = b'\xfa\xfb\xfc\xfd\xfe\xff'
1131	n/a	msg = MIMEApplication(bytes)
1132	n/a	eq(msg.get_payload(), '+vv8/f7/')
1133	n/a	eq(msg.get_payload(decode=True), bytes)
1134	n/a
1135	n/a
1136	n/a
1137	n/a	# Test the basic MIMEText class
1138	n/a	class TestMIMEText(unittest.TestCase):
1139	n/a	def setUp(self):
1140	n/a	self._msg = MIMEText('hello there')
1141	n/a
1142	n/a	def test_types(self):
1143	n/a	eq = self.assertEqual
1144	n/a	unless = self.assertTrue
1145	n/a	eq(self._msg.get_content_type(), 'text/plain')
1146	n/a	eq(self._msg.get_param('charset'), 'us-ascii')
1147	n/a	missing = []
1148	n/a	unless(self._msg.get_param('foobar', missing) is missing)
1149	n/a	unless(self._msg.get_param('charset', missing, header='foobar')
1150	n/a	is missing)
1151	n/a
1152	n/a	def test_payload(self):
1153	n/a	self.assertEqual(self._msg.get_payload(), 'hello there')
1154	n/a	self.assertTrue(not self._msg.is_multipart())
1155	n/a
1156	n/a	def test_charset(self):
1157	n/a	eq = self.assertEqual
1158	n/a	msg = MIMEText('hello there', _charset='us-ascii')
1159	n/a	eq(msg.get_charset().input_charset, 'us-ascii')
1160	n/a	eq(msg['content-type'], 'text/plain; charset="us-ascii"')
1161	n/a
1162	n/a	def test_7bit_input(self):
1163	n/a	eq = self.assertEqual
1164	n/a	msg = MIMEText('hello there', _charset='us-ascii')
1165	n/a	eq(msg.get_charset().input_charset, 'us-ascii')
1166	n/a	eq(msg['content-type'], 'text/plain; charset="us-ascii"')
1167	n/a
1168	n/a	def test_7bit_input_no_charset(self):
1169	n/a	eq = self.assertEqual
1170	n/a	msg = MIMEText('hello there')
1171	n/a	eq(msg.get_charset(), 'us-ascii')
1172	n/a	eq(msg['content-type'], 'text/plain; charset="us-ascii"')
1173	n/a	self.assertTrue('hello there' in msg.as_string())
1174	n/a
1175	n/a	def test_utf8_input(self):
1176	n/a	teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430'
1177	n/a	eq = self.assertEqual
1178	n/a	msg = MIMEText(teststr, _charset='utf-8')
1179	n/a	eq(msg.get_charset().output_charset, 'utf-8')
1180	n/a	eq(msg['content-type'], 'text/plain; charset="utf-8"')
1181	n/a	eq(msg.get_payload(decode=True), teststr.encode('utf-8'))
1182	n/a
1183	n/a	@unittest.skip("can't fix because of backward compat in email5, "
1184	n/a	"will fix in email6")
1185	n/a	def test_utf8_input_no_charset(self):
1186	n/a	teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430'
1187	n/a	self.assertRaises(UnicodeEncodeError, MIMEText, teststr)
1188	n/a
1189	n/a
1190	n/a
1191	n/a	# Test complicated multipart/* messages
1192	n/a	class TestMultipart(TestEmailBase):
1193	n/a	def setUp(self):
1194	n/a	with openfile('PyBanner048.gif', 'rb') as fp:
1195	n/a	data = fp.read()
1196	n/a	container = MIMEBase('multipart', 'mixed', boundary='BOUNDARY')
1197	n/a	image = MIMEImage(data, name='dingusfish.gif')
1198	n/a	image.add_header('content-disposition', 'attachment',
1199	n/a	filename='dingusfish.gif')
1200	n/a	intro = MIMEText('''\
1201	n/a	Hi there,
1202	n/a
1203	n/a	This is the dingus fish.
1204	n/a	''')
1205	n/a	container.attach(intro)
1206	n/a	container.attach(image)
1207	n/a	container['From'] = 'Barry <barry@digicool.com>'
1208	n/a	container['To'] = 'Dingus Lovers <cravindogs@cravindogs.com>'
1209	n/a	container['Subject'] = 'Here is your dingus fish'
1210	n/a
1211	n/a	now = 987809702.54848599
1212	n/a	timetuple = time.localtime(now)
1213	n/a	if timetuple[-1] == 0:
1214	n/a	tzsecs = time.timezone
1215	n/a	else:
1216	n/a	tzsecs = time.altzone
1217	n/a	if tzsecs > 0:
1218	n/a	sign = '-'
1219	n/a	else:
1220	n/a	sign = '+'
1221	n/a	tzoffset = ' %s%04d' % (sign, tzsecs / 36)
1222	n/a	container['Date'] = time.strftime(
1223	n/a	'%a, %d %b %Y %H:%M:%S',
1224	n/a	time.localtime(now)) + tzoffset
1225	n/a	self._msg = container
1226	n/a	self._im = image
1227	n/a	self._txt = intro
1228	n/a
1229	n/a	def test_hierarchy(self):
1230	n/a	# convenience
1231	n/a	eq = self.assertEqual
1232	n/a	unless = self.assertTrue
1233	n/a	raises = self.assertRaises
1234	n/a	# tests
1235	n/a	m = self._msg
1236	n/a	unless(m.is_multipart())
1237	n/a	eq(m.get_content_type(), 'multipart/mixed')
1238	n/a	eq(len(m.get_payload()), 2)
1239	n/a	raises(IndexError, m.get_payload, 2)
1240	n/a	m0 = m.get_payload(0)
1241	n/a	m1 = m.get_payload(1)
1242	n/a	unless(m0 is self._txt)
1243	n/a	unless(m1 is self._im)
1244	n/a	eq(m.get_payload(), [m0, m1])
1245	n/a	unless(not m0.is_multipart())
1246	n/a	unless(not m1.is_multipart())
1247	n/a
1248	n/a	def test_empty_multipart_idempotent(self):
1249	n/a	text = """\
1250	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1251	n/a	MIME-Version: 1.0
1252	n/a	Subject: A subject
1253	n/a	To: aperson@dom.ain
1254	n/a	From: bperson@dom.ain
1255	n/a
1256	n/a
1257	n/a	--BOUNDARY
1258	n/a
1259	n/a
1260	n/a	--BOUNDARY--
1261	n/a	"""
1262	n/a	msg = Parser().parsestr(text)
1263	n/a	self.ndiffAssertEqual(text, msg.as_string())
1264	n/a
1265	n/a	def test_no_parts_in_a_multipart_with_none_epilogue(self):
1266	n/a	outer = MIMEBase('multipart', 'mixed')
1267	n/a	outer['Subject'] = 'A subject'
1268	n/a	outer['To'] = 'aperson@dom.ain'
1269	n/a	outer['From'] = 'bperson@dom.ain'
1270	n/a	outer.set_boundary('BOUNDARY')
1271	n/a	self.ndiffAssertEqual(outer.as_string(), '''\
1272	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1273	n/a	MIME-Version: 1.0
1274	n/a	Subject: A subject
1275	n/a	To: aperson@dom.ain
1276	n/a	From: bperson@dom.ain
1277	n/a
1278	n/a	--BOUNDARY
1279	n/a
1280	n/a	--BOUNDARY--''')
1281	n/a
1282	n/a	def test_no_parts_in_a_multipart_with_empty_epilogue(self):
1283	n/a	outer = MIMEBase('multipart', 'mixed')
1284	n/a	outer['Subject'] = 'A subject'
1285	n/a	outer['To'] = 'aperson@dom.ain'
1286	n/a	outer['From'] = 'bperson@dom.ain'
1287	n/a	outer.preamble = ''
1288	n/a	outer.epilogue = ''
1289	n/a	outer.set_boundary('BOUNDARY')
1290	n/a	self.ndiffAssertEqual(outer.as_string(), '''\
1291	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1292	n/a	MIME-Version: 1.0
1293	n/a	Subject: A subject
1294	n/a	To: aperson@dom.ain
1295	n/a	From: bperson@dom.ain
1296	n/a
1297	n/a
1298	n/a	--BOUNDARY
1299	n/a
1300	n/a	--BOUNDARY--
1301	n/a	''')
1302	n/a
1303	n/a	def test_one_part_in_a_multipart(self):
1304	n/a	eq = self.ndiffAssertEqual
1305	n/a	outer = MIMEBase('multipart', 'mixed')
1306	n/a	outer['Subject'] = 'A subject'
1307	n/a	outer['To'] = 'aperson@dom.ain'
1308	n/a	outer['From'] = 'bperson@dom.ain'
1309	n/a	outer.set_boundary('BOUNDARY')
1310	n/a	msg = MIMEText('hello world')
1311	n/a	outer.attach(msg)
1312	n/a	eq(outer.as_string(), '''\
1313	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1314	n/a	MIME-Version: 1.0
1315	n/a	Subject: A subject
1316	n/a	To: aperson@dom.ain
1317	n/a	From: bperson@dom.ain
1318	n/a
1319	n/a	--BOUNDARY
1320	n/a	Content-Type: text/plain; charset="us-ascii"
1321	n/a	MIME-Version: 1.0
1322	n/a	Content-Transfer-Encoding: 7bit
1323	n/a
1324	n/a	hello world
1325	n/a	--BOUNDARY--''')
1326	n/a
1327	n/a	def test_seq_parts_in_a_multipart_with_empty_preamble(self):
1328	n/a	eq = self.ndiffAssertEqual
1329	n/a	outer = MIMEBase('multipart', 'mixed')
1330	n/a	outer['Subject'] = 'A subject'
1331	n/a	outer['To'] = 'aperson@dom.ain'
1332	n/a	outer['From'] = 'bperson@dom.ain'
1333	n/a	outer.preamble = ''
1334	n/a	msg = MIMEText('hello world')
1335	n/a	outer.attach(msg)
1336	n/a	outer.set_boundary('BOUNDARY')
1337	n/a	eq(outer.as_string(), '''\
1338	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1339	n/a	MIME-Version: 1.0
1340	n/a	Subject: A subject
1341	n/a	To: aperson@dom.ain
1342	n/a	From: bperson@dom.ain
1343	n/a
1344	n/a
1345	n/a	--BOUNDARY
1346	n/a	Content-Type: text/plain; charset="us-ascii"
1347	n/a	MIME-Version: 1.0
1348	n/a	Content-Transfer-Encoding: 7bit
1349	n/a
1350	n/a	hello world
1351	n/a	--BOUNDARY--''')
1352	n/a
1353	n/a
1354	n/a	def test_seq_parts_in_a_multipart_with_none_preamble(self):
1355	n/a	eq = self.ndiffAssertEqual
1356	n/a	outer = MIMEBase('multipart', 'mixed')
1357	n/a	outer['Subject'] = 'A subject'
1358	n/a	outer['To'] = 'aperson@dom.ain'
1359	n/a	outer['From'] = 'bperson@dom.ain'
1360	n/a	outer.preamble = None
1361	n/a	msg = MIMEText('hello world')
1362	n/a	outer.attach(msg)
1363	n/a	outer.set_boundary('BOUNDARY')
1364	n/a	eq(outer.as_string(), '''\
1365	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1366	n/a	MIME-Version: 1.0
1367	n/a	Subject: A subject
1368	n/a	To: aperson@dom.ain
1369	n/a	From: bperson@dom.ain
1370	n/a
1371	n/a	--BOUNDARY
1372	n/a	Content-Type: text/plain; charset="us-ascii"
1373	n/a	MIME-Version: 1.0
1374	n/a	Content-Transfer-Encoding: 7bit
1375	n/a
1376	n/a	hello world
1377	n/a	--BOUNDARY--''')
1378	n/a
1379	n/a
1380	n/a	def test_seq_parts_in_a_multipart_with_none_epilogue(self):
1381	n/a	eq = self.ndiffAssertEqual
1382	n/a	outer = MIMEBase('multipart', 'mixed')
1383	n/a	outer['Subject'] = 'A subject'
1384	n/a	outer['To'] = 'aperson@dom.ain'
1385	n/a	outer['From'] = 'bperson@dom.ain'
1386	n/a	outer.epilogue = None
1387	n/a	msg = MIMEText('hello world')
1388	n/a	outer.attach(msg)
1389	n/a	outer.set_boundary('BOUNDARY')
1390	n/a	eq(outer.as_string(), '''\
1391	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1392	n/a	MIME-Version: 1.0
1393	n/a	Subject: A subject
1394	n/a	To: aperson@dom.ain
1395	n/a	From: bperson@dom.ain
1396	n/a
1397	n/a	--BOUNDARY
1398	n/a	Content-Type: text/plain; charset="us-ascii"
1399	n/a	MIME-Version: 1.0
1400	n/a	Content-Transfer-Encoding: 7bit
1401	n/a
1402	n/a	hello world
1403	n/a	--BOUNDARY--''')
1404	n/a
1405	n/a
1406	n/a	def test_seq_parts_in_a_multipart_with_empty_epilogue(self):
1407	n/a	eq = self.ndiffAssertEqual
1408	n/a	outer = MIMEBase('multipart', 'mixed')
1409	n/a	outer['Subject'] = 'A subject'
1410	n/a	outer['To'] = 'aperson@dom.ain'
1411	n/a	outer['From'] = 'bperson@dom.ain'
1412	n/a	outer.epilogue = ''
1413	n/a	msg = MIMEText('hello world')
1414	n/a	outer.attach(msg)
1415	n/a	outer.set_boundary('BOUNDARY')
1416	n/a	eq(outer.as_string(), '''\
1417	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1418	n/a	MIME-Version: 1.0
1419	n/a	Subject: A subject
1420	n/a	To: aperson@dom.ain
1421	n/a	From: bperson@dom.ain
1422	n/a
1423	n/a	--BOUNDARY
1424	n/a	Content-Type: text/plain; charset="us-ascii"
1425	n/a	MIME-Version: 1.0
1426	n/a	Content-Transfer-Encoding: 7bit
1427	n/a
1428	n/a	hello world
1429	n/a	--BOUNDARY--
1430	n/a	''')
1431	n/a
1432	n/a
1433	n/a	def test_seq_parts_in_a_multipart_with_nl_epilogue(self):
1434	n/a	eq = self.ndiffAssertEqual
1435	n/a	outer = MIMEBase('multipart', 'mixed')
1436	n/a	outer['Subject'] = 'A subject'
1437	n/a	outer['To'] = 'aperson@dom.ain'
1438	n/a	outer['From'] = 'bperson@dom.ain'
1439	n/a	outer.epilogue = '\n'
1440	n/a	msg = MIMEText('hello world')
1441	n/a	outer.attach(msg)
1442	n/a	outer.set_boundary('BOUNDARY')
1443	n/a	eq(outer.as_string(), '''\
1444	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1445	n/a	MIME-Version: 1.0
1446	n/a	Subject: A subject
1447	n/a	To: aperson@dom.ain
1448	n/a	From: bperson@dom.ain
1449	n/a
1450	n/a	--BOUNDARY
1451	n/a	Content-Type: text/plain; charset="us-ascii"
1452	n/a	MIME-Version: 1.0
1453	n/a	Content-Transfer-Encoding: 7bit
1454	n/a
1455	n/a	hello world
1456	n/a	--BOUNDARY--
1457	n/a
1458	n/a	''')
1459	n/a
1460	n/a	def test_message_external_body(self):
1461	n/a	eq = self.assertEqual
1462	n/a	msg = self._msgobj('msg_36.txt')
1463	n/a	eq(len(msg.get_payload()), 2)
1464	n/a	msg1 = msg.get_payload(1)
1465	n/a	eq(msg1.get_content_type(), 'multipart/alternative')
1466	n/a	eq(len(msg1.get_payload()), 2)
1467	n/a	for subpart in msg1.get_payload():
1468	n/a	eq(subpart.get_content_type(), 'message/external-body')
1469	n/a	eq(len(subpart.get_payload()), 1)
1470	n/a	subsubpart = subpart.get_payload(0)
1471	n/a	eq(subsubpart.get_content_type(), 'text/plain')
1472	n/a
1473	n/a	def test_double_boundary(self):
1474	n/a	# msg_37.txt is a multipart that contains two dash-boundary's in a
1475	n/a	# row. Our interpretation of RFC 2046 calls for ignoring the second
1476	n/a	# and subsequent boundaries.
1477	n/a	msg = self._msgobj('msg_37.txt')
1478	n/a	self.assertEqual(len(msg.get_payload()), 3)
1479	n/a
1480	n/a	def test_nested_inner_contains_outer_boundary(self):
1481	n/a	eq = self.ndiffAssertEqual
1482	n/a	# msg_38.txt has an inner part that contains outer boundaries. My
1483	n/a	# interpretation of RFC 2046 (based on sections 5.1 and 5.1.2) say
1484	n/a	# these are illegal and should be interpreted as unterminated inner
1485	n/a	# parts.
1486	n/a	msg = self._msgobj('msg_38.txt')
1487	n/a	sfp = StringIO()
1488	n/a	iterators._structure(msg, sfp)
1489	n/a	eq(sfp.getvalue(), """\
1490	n/a	multipart/mixed
1491	n/a	multipart/mixed
1492	n/a	multipart/alternative
1493	n/a	text/plain
1494	n/a	text/plain
1495	n/a	text/plain
1496	n/a	text/plain
1497	n/a	""")
1498	n/a
1499	n/a	def test_nested_with_same_boundary(self):
1500	n/a	eq = self.ndiffAssertEqual
1501	n/a	# msg 39.txt is similarly evil in that it's got inner parts that use
1502	n/a	# the same boundary as outer parts. Again, I believe the way this is
1503	n/a	# parsed is closest to the spirit of RFC 2046
1504	n/a	msg = self._msgobj('msg_39.txt')
1505	n/a	sfp = StringIO()
1506	n/a	iterators._structure(msg, sfp)
1507	n/a	eq(sfp.getvalue(), """\
1508	n/a	multipart/mixed
1509	n/a	multipart/mixed
1510	n/a	multipart/alternative
1511	n/a	application/octet-stream
1512	n/a	application/octet-stream
1513	n/a	text/plain
1514	n/a	""")
1515	n/a
1516	n/a	def test_boundary_in_non_multipart(self):
1517	n/a	msg = self._msgobj('msg_40.txt')
1518	n/a	self.assertEqual(msg.as_string(), '''\
1519	n/a	MIME-Version: 1.0
1520	n/a	Content-Type: text/html; boundary="--961284236552522269"
1521	n/a
1522	n/a	----961284236552522269
1523	n/a	Content-Type: text/html;
1524	n/a	Content-Transfer-Encoding: 7Bit
1525	n/a
1526	n/a	<html></html>
1527	n/a
1528	n/a	----961284236552522269--
1529	n/a	''')
1530	n/a
1531	n/a	def test_boundary_with_leading_space(self):
1532	n/a	eq = self.assertEqual
1533	n/a	msg = email.message_from_string('''\
1534	n/a	MIME-Version: 1.0
1535	n/a	Content-Type: multipart/mixed; boundary=" XXXX"
1536	n/a
1537	n/a	-- XXXX
1538	n/a	Content-Type: text/plain
1539	n/a
1540	n/a
1541	n/a	-- XXXX
1542	n/a	Content-Type: text/plain
1543	n/a
1544	n/a	-- XXXX--
1545	n/a	''')
1546	n/a	self.assertTrue(msg.is_multipart())
1547	n/a	eq(msg.get_boundary(), ' XXXX')
1548	n/a	eq(len(msg.get_payload()), 2)
1549	n/a
1550	n/a	def test_boundary_without_trailing_newline(self):
1551	n/a	m = Parser().parsestr("""\
1552	n/a	Content-Type: multipart/mixed; boundary="===============0012394164=="
1553	n/a	MIME-Version: 1.0
1554	n/a
1555	n/a	--===============0012394164==
1556	n/a	Content-Type: image/file1.jpg
1557	n/a	MIME-Version: 1.0
1558	n/a	Content-Transfer-Encoding: base64
1559	n/a
1560	n/a	YXNkZg==
1561	n/a	--===============0012394164==--""")
1562	n/a	self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
1563	n/a
1564	n/a
1565	n/a
1566	n/a	# Test some badly formatted messages
1567	n/a	class TestNonConformant(TestEmailBase):
1568	n/a	def test_parse_missing_minor_type(self):
1569	n/a	eq = self.assertEqual
1570	n/a	msg = self._msgobj('msg_14.txt')
1571	n/a	eq(msg.get_content_type(), 'text/plain')
1572	n/a	eq(msg.get_content_maintype(), 'text')
1573	n/a	eq(msg.get_content_subtype(), 'plain')
1574	n/a
1575	n/a	def test_same_boundary_inner_outer(self):
1576	n/a	unless = self.assertTrue
1577	n/a	msg = self._msgobj('msg_15.txt')
1578	n/a	# XXX We can probably eventually do better
1579	n/a	inner = msg.get_payload(0)
1580	n/a	unless(hasattr(inner, 'defects'))
1581	n/a	self.assertEqual(len(inner.defects), 1)
1582	n/a	unless(isinstance(inner.defects[0],
1583	n/a	errors.StartBoundaryNotFoundDefect))
1584	n/a
1585	n/a	def test_multipart_no_boundary(self):
1586	n/a	unless = self.assertTrue
1587	n/a	msg = self._msgobj('msg_25.txt')
1588	n/a	unless(isinstance(msg.get_payload(), str))
1589	n/a	self.assertEqual(len(msg.defects), 2)
1590	n/a	unless(isinstance(msg.defects[0], errors.NoBoundaryInMultipartDefect))
1591	n/a	unless(isinstance(msg.defects[1],
1592	n/a	errors.MultipartInvariantViolationDefect))
1593	n/a
1594	n/a	def test_invalid_content_type(self):
1595	n/a	eq = self.assertEqual
1596	n/a	neq = self.ndiffAssertEqual
1597	n/a	msg = Message()
1598	n/a	# RFC 2045, $5.2 says invalid yields text/plain
1599	n/a	msg['Content-Type'] = 'text'
1600	n/a	eq(msg.get_content_maintype(), 'text')
1601	n/a	eq(msg.get_content_subtype(), 'plain')
1602	n/a	eq(msg.get_content_type(), 'text/plain')
1603	n/a	# Clear the old value and try something /really/ invalid
1604	n/a	del msg['content-type']
1605	n/a	msg['Content-Type'] = 'foo'
1606	n/a	eq(msg.get_content_maintype(), 'text')
1607	n/a	eq(msg.get_content_subtype(), 'plain')
1608	n/a	eq(msg.get_content_type(), 'text/plain')
1609	n/a	# Still, make sure that the message is idempotently generated
1610	n/a	s = StringIO()
1611	n/a	g = Generator(s)
1612	n/a	g.flatten(msg)
1613	n/a	neq(s.getvalue(), 'Content-Type: foo\n\n')
1614	n/a
1615	n/a	def test_no_start_boundary(self):
1616	n/a	eq = self.ndiffAssertEqual
1617	n/a	msg = self._msgobj('msg_31.txt')
1618	n/a	eq(msg.get_payload(), """\
1619	n/a	--BOUNDARY
1620	n/a	Content-Type: text/plain
1621	n/a
1622	n/a	message 1
1623	n/a
1624	n/a	--BOUNDARY
1625	n/a	Content-Type: text/plain
1626	n/a
1627	n/a	message 2
1628	n/a
1629	n/a	--BOUNDARY--
1630	n/a	""")
1631	n/a
1632	n/a	def test_no_separating_blank_line(self):
1633	n/a	eq = self.ndiffAssertEqual
1634	n/a	msg = self._msgobj('msg_35.txt')
1635	n/a	eq(msg.as_string(), """\
1636	n/a	From: aperson@dom.ain
1637	n/a	To: bperson@dom.ain
1638	n/a	Subject: here's something interesting
1639	n/a
1640	n/a	counter to RFC 2822, there's no separating newline here
1641	n/a	""")
1642	n/a
1643	n/a	def test_lying_multipart(self):
1644	n/a	unless = self.assertTrue
1645	n/a	msg = self._msgobj('msg_41.txt')
1646	n/a	unless(hasattr(msg, 'defects'))
1647	n/a	self.assertEqual(len(msg.defects), 2)
1648	n/a	unless(isinstance(msg.defects[0], errors.NoBoundaryInMultipartDefect))
1649	n/a	unless(isinstance(msg.defects[1],
1650	n/a	errors.MultipartInvariantViolationDefect))
1651	n/a
1652	n/a	def test_missing_start_boundary(self):
1653	n/a	outer = self._msgobj('msg_42.txt')
1654	n/a	# The message structure is:
1655	n/a	#
1656	n/a	# multipart/mixed
1657	n/a	# text/plain
1658	n/a	# message/rfc822
1659	n/a	# multipart/mixed [*]
1660	n/a	#
1661	n/a	# [*] This message is missing its start boundary
1662	n/a	bad = outer.get_payload(1).get_payload(0)
1663	n/a	self.assertEqual(len(bad.defects), 1)
1664	n/a	self.assertTrue(isinstance(bad.defects[0],
1665	n/a	errors.StartBoundaryNotFoundDefect))
1666	n/a
1667	n/a	def test_first_line_is_continuation_header(self):
1668	n/a	eq = self.assertEqual
1669	n/a	m = ' Line 1\nLine 2\nLine 3'
1670	n/a	msg = email.message_from_string(m)
1671	n/a	eq(msg.keys(), [])
1672	n/a	eq(msg.get_payload(), 'Line 2\nLine 3')
1673	n/a	eq(len(msg.defects), 1)
1674	n/a	self.assertTrue(isinstance(msg.defects[0],
1675	n/a	errors.FirstHeaderLineIsContinuationDefect))
1676	n/a	eq(msg.defects[0].line, ' Line 1\n')
1677	n/a
1678	n/a
1679	n/a
1680	n/a	# Test RFC 2047 header encoding and decoding
1681	n/a	class TestRFC2047(TestEmailBase):
1682	n/a	def test_rfc2047_multiline(self):
1683	n/a	eq = self.assertEqual
1684	n/a	s = """Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz
1685	n/a	foo bar =?mac-iceland?q?r=8Aksm=9Arg=8Cs?="""
1686	n/a	dh = decode_header(s)
1687	n/a	eq(dh, [
1688	n/a	(b'Re:', None),
1689	n/a	(b'r\x8aksm\x9arg\x8cs', 'mac-iceland'),
1690	n/a	(b'baz foo bar', None),
1691	n/a	(b'r\x8aksm\x9arg\x8cs', 'mac-iceland')])
1692	n/a	header = make_header(dh)
1693	n/a	eq(str(header),
1694	n/a	'Re: r\xe4ksm\xf6rg\xe5s baz foo bar r\xe4ksm\xf6rg\xe5s')
1695	n/a	self.ndiffAssertEqual(header.encode(maxlinelen=76), """\
1696	n/a	Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz foo bar =?mac-iceland?q?r=8Aksm?=
1697	n/a	=?mac-iceland?q?=9Arg=8Cs?=""")
1698	n/a
1699	n/a	def test_whitespace_eater_unicode(self):
1700	n/a	eq = self.assertEqual
1701	n/a	s = '=?ISO-8859-1?Q?Andr=E9?= Pirard <pirard@dom.ain>'
1702	n/a	dh = decode_header(s)
1703	n/a	eq(dh, [(b'Andr\xe9', 'iso-8859-1'),
1704	n/a	(b'Pirard <pirard@dom.ain>', None)])
1705	n/a	header = str(make_header(dh))
1706	n/a	eq(header, 'Andr\xe9 Pirard <pirard@dom.ain>')
1707	n/a
1708	n/a	def test_whitespace_eater_unicode_2(self):
1709	n/a	eq = self.assertEqual
1710	n/a	s = 'The =?iso-8859-1?b?cXVpY2sgYnJvd24gZm94?= jumped over the =?iso-8859-1?b?bGF6eSBkb2c=?='
1711	n/a	dh = decode_header(s)
1712	n/a	eq(dh, [(b'The', None), (b'quick brown fox', 'iso-8859-1'),
1713	n/a	(b'jumped over the', None), (b'lazy dog', 'iso-8859-1')])
1714	n/a	hu = str(make_header(dh))
1715	n/a	eq(hu, 'The quick brown fox jumped over the lazy dog')
1716	n/a
1717	n/a	def test_rfc2047_missing_whitespace(self):
1718	n/a	s = 'Sm=?ISO-8859-1?B?9g==?=rg=?ISO-8859-1?B?5Q==?=sbord'
1719	n/a	dh = decode_header(s)
1720	n/a	self.assertEqual(dh, [(s, None)])
1721	n/a
1722	n/a	def test_rfc2047_with_whitespace(self):
1723	n/a	s = 'Sm =?ISO-8859-1?B?9g==?= rg =?ISO-8859-1?B?5Q==?= sbord'
1724	n/a	dh = decode_header(s)
1725	n/a	self.assertEqual(dh, [(b'Sm', None), (b'\xf6', 'iso-8859-1'),
1726	n/a	(b'rg', None), (b'\xe5', 'iso-8859-1'),
1727	n/a	(b'sbord', None)])
1728	n/a
1729	n/a	def test_rfc2047_B_bad_padding(self):
1730	n/a	s = '=?iso-8859-1?B?%s?='
1731	n/a	data = [ # only test complete bytes
1732	n/a	('dm==', b'v'), ('dm=', b'v'), ('dm', b'v'),
1733	n/a	('dmk=', b'vi'), ('dmk', b'vi')
1734	n/a	]
1735	n/a	for q, a in data:
1736	n/a	dh = decode_header(s % q)
1737	n/a	self.assertEqual(dh, [(a, 'iso-8859-1')])
1738	n/a
1739	n/a	def test_rfc2047_Q_invalid_digits(self):
1740	n/a	# issue 10004.
1741	n/a	s = '=?iso-8659-1?Q?andr=e9=zz?='
1742	n/a	self.assertEqual(decode_header(s),
1743	n/a	[(b'andr\xe9=zz', 'iso-8659-1')])
1744	n/a
1745	n/a
1746	n/a	# Test the MIMEMessage class
1747	n/a	class TestMIMEMessage(TestEmailBase):
1748	n/a	def setUp(self):
1749	n/a	with openfile('msg_11.txt') as fp:
1750	n/a	self._text = fp.read()
1751	n/a
1752	n/a	def test_type_error(self):
1753	n/a	self.assertRaises(TypeError, MIMEMessage, 'a plain string')
1754	n/a
1755	n/a	def test_valid_argument(self):
1756	n/a	eq = self.assertEqual
1757	n/a	unless = self.assertTrue
1758	n/a	subject = 'A sub-message'
1759	n/a	m = Message()
1760	n/a	m['Subject'] = subject
1761	n/a	r = MIMEMessage(m)
1762	n/a	eq(r.get_content_type(), 'message/rfc822')
1763	n/a	payload = r.get_payload()
1764	n/a	unless(isinstance(payload, list))
1765	n/a	eq(len(payload), 1)
1766	n/a	subpart = payload[0]
1767	n/a	unless(subpart is m)
1768	n/a	eq(subpart['subject'], subject)
1769	n/a
1770	n/a	def test_bad_multipart(self):
1771	n/a	eq = self.assertEqual
1772	n/a	msg1 = Message()
1773	n/a	msg1['Subject'] = 'subpart 1'
1774	n/a	msg2 = Message()
1775	n/a	msg2['Subject'] = 'subpart 2'
1776	n/a	r = MIMEMessage(msg1)
1777	n/a	self.assertRaises(errors.MultipartConversionError, r.attach, msg2)
1778	n/a
1779	n/a	def test_generate(self):
1780	n/a	# First craft the message to be encapsulated
1781	n/a	m = Message()
1782	n/a	m['Subject'] = 'An enclosed message'
1783	n/a	m.set_payload('Here is the body of the message.\n')
1784	n/a	r = MIMEMessage(m)
1785	n/a	r['Subject'] = 'The enclosing message'
1786	n/a	s = StringIO()
1787	n/a	g = Generator(s)
1788	n/a	g.flatten(r)
1789	n/a	self.assertEqual(s.getvalue(), """\
1790	n/a	Content-Type: message/rfc822
1791	n/a	MIME-Version: 1.0
1792	n/a	Subject: The enclosing message
1793	n/a
1794	n/a	Subject: An enclosed message
1795	n/a
1796	n/a	Here is the body of the message.
1797	n/a	""")
1798	n/a
1799	n/a	def test_parse_message_rfc822(self):
1800	n/a	eq = self.assertEqual
1801	n/a	unless = self.assertTrue
1802	n/a	msg = self._msgobj('msg_11.txt')
1803	n/a	eq(msg.get_content_type(), 'message/rfc822')
1804	n/a	payload = msg.get_payload()
1805	n/a	unless(isinstance(payload, list))
1806	n/a	eq(len(payload), 1)
1807	n/a	submsg = payload[0]
1808	n/a	self.assertTrue(isinstance(submsg, Message))
1809	n/a	eq(submsg['subject'], 'An enclosed message')
1810	n/a	eq(submsg.get_payload(), 'Here is the body of the message.\n')
1811	n/a
1812	n/a	def test_dsn(self):
1813	n/a	eq = self.assertEqual
1814	n/a	unless = self.assertTrue
1815	n/a	# msg 16 is a Delivery Status Notification, see RFC 1894
1816	n/a	msg = self._msgobj('msg_16.txt')
1817	n/a	eq(msg.get_content_type(), 'multipart/report')
1818	n/a	unless(msg.is_multipart())
1819	n/a	eq(len(msg.get_payload()), 3)
1820	n/a	# Subpart 1 is a text/plain, human readable section
1821	n/a	subpart = msg.get_payload(0)
1822	n/a	eq(subpart.get_content_type(), 'text/plain')
1823	n/a	eq(subpart.get_payload(), """\
1824	n/a	This report relates to a message you sent with the following header fields:
1825	n/a
1826	n/a	Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
1827	n/a	Date: Sun, 23 Sep 2001 20:10:55 -0700
1828	n/a	From: "Ian T. Henry" <henryi@oxy.edu>
1829	n/a	To: SoCal Raves <scr@socal-raves.org>
1830	n/a	Subject: [scr] yeah for Ians!!
1831	n/a
1832	n/a	Your message cannot be delivered to the following recipients:
1833	n/a
1834	n/a	Recipient address: jangel1@cougar.noc.ucla.edu
1835	n/a	Reason: recipient reached disk quota
1836	n/a
1837	n/a	""")
1838	n/a	# Subpart 2 contains the machine parsable DSN information. It
1839	n/a	# consists of two blocks of headers, represented by two nested Message
1840	n/a	# objects.
1841	n/a	subpart = msg.get_payload(1)
1842	n/a	eq(subpart.get_content_type(), 'message/delivery-status')
1843	n/a	eq(len(subpart.get_payload()), 2)
1844	n/a	# message/delivery-status should treat each block as a bunch of
1845	n/a	# headers, i.e. a bunch of Message objects.
1846	n/a	dsn1 = subpart.get_payload(0)
1847	n/a	unless(isinstance(dsn1, Message))
1848	n/a	eq(dsn1['original-envelope-id'], '0GK500B4HD0888@cougar.noc.ucla.edu')
1849	n/a	eq(dsn1.get_param('dns', header='reporting-mta'), '')
1850	n/a	# Try a missing one <wink>
1851	n/a	eq(dsn1.get_param('nsd', header='reporting-mta'), None)
1852	n/a	dsn2 = subpart.get_payload(1)
1853	n/a	unless(isinstance(dsn2, Message))
1854	n/a	eq(dsn2['action'], 'failed')
1855	n/a	eq(dsn2.get_params(header='original-recipient'),
1856	n/a	[('rfc822', ''), ('jangel1@cougar.noc.ucla.edu', '')])
1857	n/a	eq(dsn2.get_param('rfc822', header='final-recipient'), '')
1858	n/a	# Subpart 3 is the original message
1859	n/a	subpart = msg.get_payload(2)
1860	n/a	eq(subpart.get_content_type(), 'message/rfc822')
1861	n/a	payload = subpart.get_payload()
1862	n/a	unless(isinstance(payload, list))
1863	n/a	eq(len(payload), 1)
1864	n/a	subsubpart = payload[0]
1865	n/a	unless(isinstance(subsubpart, Message))
1866	n/a	eq(subsubpart.get_content_type(), 'text/plain')
1867	n/a	eq(subsubpart['message-id'],
1868	n/a	'<002001c144a6$8752e060$56104586@oxy.edu>')
1869	n/a
1870	n/a	def test_epilogue(self):
1871	n/a	eq = self.ndiffAssertEqual
1872	n/a	with openfile('msg_21.txt') as fp:
1873	n/a	text = fp.read()
1874	n/a	msg = Message()
1875	n/a	msg['From'] = 'aperson@dom.ain'
1876	n/a	msg['To'] = 'bperson@dom.ain'
1877	n/a	msg['Subject'] = 'Test'
1878	n/a	msg.preamble = 'MIME message'
1879	n/a	msg.epilogue = 'End of MIME message\n'
1880	n/a	msg1 = MIMEText('One')
1881	n/a	msg2 = MIMEText('Two')
1882	n/a	msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')
1883	n/a	msg.attach(msg1)
1884	n/a	msg.attach(msg2)
1885	n/a	sfp = StringIO()
1886	n/a	g = Generator(sfp)
1887	n/a	g.flatten(msg)
1888	n/a	eq(sfp.getvalue(), text)
1889	n/a
1890	n/a	def test_no_nl_preamble(self):
1891	n/a	eq = self.ndiffAssertEqual
1892	n/a	msg = Message()
1893	n/a	msg['From'] = 'aperson@dom.ain'
1894	n/a	msg['To'] = 'bperson@dom.ain'
1895	n/a	msg['Subject'] = 'Test'
1896	n/a	msg.preamble = 'MIME message'
1897	n/a	msg.epilogue = ''
1898	n/a	msg1 = MIMEText('One')
1899	n/a	msg2 = MIMEText('Two')
1900	n/a	msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')
1901	n/a	msg.attach(msg1)
1902	n/a	msg.attach(msg2)
1903	n/a	eq(msg.as_string(), """\
1904	n/a	From: aperson@dom.ain
1905	n/a	To: bperson@dom.ain
1906	n/a	Subject: Test
1907	n/a	Content-Type: multipart/mixed; boundary="BOUNDARY"
1908	n/a
1909	n/a	MIME message
1910	n/a	--BOUNDARY
1911	n/a	Content-Type: text/plain; charset="us-ascii"
1912	n/a	MIME-Version: 1.0
1913	n/a	Content-Transfer-Encoding: 7bit
1914	n/a
1915	n/a	One
1916	n/a	--BOUNDARY
1917	n/a	Content-Type: text/plain; charset="us-ascii"
1918	n/a	MIME-Version: 1.0
1919	n/a	Content-Transfer-Encoding: 7bit
1920	n/a
1921	n/a	Two
1922	n/a	--BOUNDARY--
1923	n/a	""")
1924	n/a
1925	n/a	def test_default_type(self):
1926	n/a	eq = self.assertEqual
1927	n/a	with openfile('msg_30.txt') as fp:
1928	n/a	msg = email.message_from_file(fp)
1929	n/a	container1 = msg.get_payload(0)
1930	n/a	eq(container1.get_default_type(), 'message/rfc822')
1931	n/a	eq(container1.get_content_type(), 'message/rfc822')
1932	n/a	container2 = msg.get_payload(1)
1933	n/a	eq(container2.get_default_type(), 'message/rfc822')
1934	n/a	eq(container2.get_content_type(), 'message/rfc822')
1935	n/a	container1a = container1.get_payload(0)
1936	n/a	eq(container1a.get_default_type(), 'text/plain')
1937	n/a	eq(container1a.get_content_type(), 'text/plain')
1938	n/a	container2a = container2.get_payload(0)
1939	n/a	eq(container2a.get_default_type(), 'text/plain')
1940	n/a	eq(container2a.get_content_type(), 'text/plain')
1941	n/a
1942	n/a	def test_default_type_with_explicit_container_type(self):
1943	n/a	eq = self.assertEqual
1944	n/a	with openfile('msg_28.txt') as fp:
1945	n/a	msg = email.message_from_file(fp)
1946	n/a	container1 = msg.get_payload(0)
1947	n/a	eq(container1.get_default_type(), 'message/rfc822')
1948	n/a	eq(container1.get_content_type(), 'message/rfc822')
1949	n/a	container2 = msg.get_payload(1)
1950	n/a	eq(container2.get_default_type(), 'message/rfc822')
1951	n/a	eq(container2.get_content_type(), 'message/rfc822')
1952	n/a	container1a = container1.get_payload(0)
1953	n/a	eq(container1a.get_default_type(), 'text/plain')
1954	n/a	eq(container1a.get_content_type(), 'text/plain')
1955	n/a	container2a = container2.get_payload(0)
1956	n/a	eq(container2a.get_default_type(), 'text/plain')
1957	n/a	eq(container2a.get_content_type(), 'text/plain')
1958	n/a
1959	n/a	def test_default_type_non_parsed(self):
1960	n/a	eq = self.assertEqual
1961	n/a	neq = self.ndiffAssertEqual
1962	n/a	# Set up container
1963	n/a	container = MIMEMultipart('digest', 'BOUNDARY')
1964	n/a	container.epilogue = ''
1965	n/a	# Set up subparts
1966	n/a	subpart1a = MIMEText('message 1\n')
1967	n/a	subpart2a = MIMEText('message 2\n')
1968	n/a	subpart1 = MIMEMessage(subpart1a)
1969	n/a	subpart2 = MIMEMessage(subpart2a)
1970	n/a	container.attach(subpart1)
1971	n/a	container.attach(subpart2)
1972	n/a	eq(subpart1.get_content_type(), 'message/rfc822')
1973	n/a	eq(subpart1.get_default_type(), 'message/rfc822')
1974	n/a	eq(subpart2.get_content_type(), 'message/rfc822')
1975	n/a	eq(subpart2.get_default_type(), 'message/rfc822')
1976	n/a	neq(container.as_string(0), '''\
1977	n/a	Content-Type: multipart/digest; boundary="BOUNDARY"
1978	n/a	MIME-Version: 1.0
1979	n/a
1980	n/a	--BOUNDARY
1981	n/a	Content-Type: message/rfc822
1982	n/a	MIME-Version: 1.0
1983	n/a
1984	n/a	Content-Type: text/plain; charset="us-ascii"
1985	n/a	MIME-Version: 1.0
1986	n/a	Content-Transfer-Encoding: 7bit
1987	n/a
1988	n/a	message 1
1989	n/a
1990	n/a	--BOUNDARY
1991	n/a	Content-Type: message/rfc822
1992	n/a	MIME-Version: 1.0
1993	n/a
1994	n/a	Content-Type: text/plain; charset="us-ascii"
1995	n/a	MIME-Version: 1.0
1996	n/a	Content-Transfer-Encoding: 7bit
1997	n/a
1998	n/a	message 2
1999	n/a
2000	n/a	--BOUNDARY--
2001	n/a	''')
2002	n/a	del subpart1['content-type']
2003	n/a	del subpart1['mime-version']
2004	n/a	del subpart2['content-type']
2005	n/a	del subpart2['mime-version']
2006	n/a	eq(subpart1.get_content_type(), 'message/rfc822')
2007	n/a	eq(subpart1.get_default_type(), 'message/rfc822')
2008	n/a	eq(subpart2.get_content_type(), 'message/rfc822')
2009	n/a	eq(subpart2.get_default_type(), 'message/rfc822')
2010	n/a	neq(container.as_string(0), '''\
2011	n/a	Content-Type: multipart/digest; boundary="BOUNDARY"
2012	n/a	MIME-Version: 1.0
2013	n/a
2014	n/a	--BOUNDARY
2015	n/a
2016	n/a	Content-Type: text/plain; charset="us-ascii"
2017	n/a	MIME-Version: 1.0
2018	n/a	Content-Transfer-Encoding: 7bit
2019	n/a
2020	n/a	message 1
2021	n/a
2022	n/a	--BOUNDARY
2023	n/a
2024	n/a	Content-Type: text/plain; charset="us-ascii"
2025	n/a	MIME-Version: 1.0
2026	n/a	Content-Transfer-Encoding: 7bit
2027	n/a
2028	n/a	message 2
2029	n/a
2030	n/a	--BOUNDARY--
2031	n/a	''')
2032	n/a
2033	n/a	def test_mime_attachments_in_constructor(self):
2034	n/a	eq = self.assertEqual
2035	n/a	text1 = MIMEText('')
2036	n/a	text2 = MIMEText('')
2037	n/a	msg = MIMEMultipart(_subparts=(text1, text2))
2038	n/a	eq(len(msg.get_payload()), 2)
2039	n/a	eq(msg.get_payload(0), text1)
2040	n/a	eq(msg.get_payload(1), text2)
2041	n/a
2042	n/a	def test_default_multipart_constructor(self):
2043	n/a	msg = MIMEMultipart()
2044	n/a	self.assertTrue(msg.is_multipart())
2045	n/a
2046	n/a
2047	n/a	# A general test of parser->model->generator idempotency. IOW, read a message
2048	n/a	# in, parse it into a message object tree, then without touching the tree,
2049	n/a	# regenerate the plain text. The original text and the transformed text
2050	n/a	# should be identical. Note: that we ignore the Unix-From since that may
2051	n/a	# contain a changed date.
2052	n/a	class TestIdempotent(TestEmailBase):
2053	n/a
2054	n/a	linesep = '\n'
2055	n/a
2056	n/a	def _msgobj(self, filename):
2057	n/a	with openfile(filename) as fp:
2058	n/a	data = fp.read()
2059	n/a	msg = email.message_from_string(data)
2060	n/a	return msg, data
2061	n/a
2062	n/a	def _idempotent(self, msg, text, unixfrom=False):
2063	n/a	eq = self.ndiffAssertEqual
2064	n/a	s = StringIO()
2065	n/a	g = Generator(s, maxheaderlen=0)
2066	n/a	g.flatten(msg, unixfrom=unixfrom)
2067	n/a	eq(text, s.getvalue())
2068	n/a
2069	n/a	def test_parse_text_message(self):
2070	n/a	eq = self.assertEqual
2071	n/a	msg, text = self._msgobj('msg_01.txt')
2072	n/a	eq(msg.get_content_type(), 'text/plain')
2073	n/a	eq(msg.get_content_maintype(), 'text')
2074	n/a	eq(msg.get_content_subtype(), 'plain')
2075	n/a	eq(msg.get_params()[1], ('charset', 'us-ascii'))
2076	n/a	eq(msg.get_param('charset'), 'us-ascii')
2077	n/a	eq(msg.preamble, None)
2078	n/a	eq(msg.epilogue, None)
2079	n/a	self._idempotent(msg, text)
2080	n/a
2081	n/a	def test_parse_untyped_message(self):
2082	n/a	eq = self.assertEqual
2083	n/a	msg, text = self._msgobj('msg_03.txt')
2084	n/a	eq(msg.get_content_type(), 'text/plain')
2085	n/a	eq(msg.get_params(), None)
2086	n/a	eq(msg.get_param('charset'), None)
2087	n/a	self._idempotent(msg, text)
2088	n/a
2089	n/a	def test_simple_multipart(self):
2090	n/a	msg, text = self._msgobj('msg_04.txt')
2091	n/a	self._idempotent(msg, text)
2092	n/a
2093	n/a	def test_MIME_digest(self):
2094	n/a	msg, text = self._msgobj('msg_02.txt')
2095	n/a	self._idempotent(msg, text)
2096	n/a
2097	n/a	def test_long_header(self):
2098	n/a	msg, text = self._msgobj('msg_27.txt')
2099	n/a	self._idempotent(msg, text)
2100	n/a
2101	n/a	def test_MIME_digest_with_part_headers(self):
2102	n/a	msg, text = self._msgobj('msg_28.txt')
2103	n/a	self._idempotent(msg, text)
2104	n/a
2105	n/a	def test_mixed_with_image(self):
2106	n/a	msg, text = self._msgobj('msg_06.txt')
2107	n/a	self._idempotent(msg, text)
2108	n/a
2109	n/a	def test_multipart_report(self):
2110	n/a	msg, text = self._msgobj('msg_05.txt')
2111	n/a	self._idempotent(msg, text)
2112	n/a
2113	n/a	def test_dsn(self):
2114	n/a	msg, text = self._msgobj('msg_16.txt')
2115	n/a	self._idempotent(msg, text)
2116	n/a
2117	n/a	def test_preamble_epilogue(self):
2118	n/a	msg, text = self._msgobj('msg_21.txt')
2119	n/a	self._idempotent(msg, text)
2120	n/a
2121	n/a	def test_multipart_one_part(self):
2122	n/a	msg, text = self._msgobj('msg_23.txt')
2123	n/a	self._idempotent(msg, text)
2124	n/a
2125	n/a	def test_multipart_no_parts(self):
2126	n/a	msg, text = self._msgobj('msg_24.txt')
2127	n/a	self._idempotent(msg, text)
2128	n/a
2129	n/a	def test_no_start_boundary(self):
2130	n/a	msg, text = self._msgobj('msg_31.txt')
2131	n/a	self._idempotent(msg, text)
2132	n/a
2133	n/a	def test_rfc2231_charset(self):
2134	n/a	msg, text = self._msgobj('msg_32.txt')
2135	n/a	self._idempotent(msg, text)
2136	n/a
2137	n/a	def test_more_rfc2231_parameters(self):
2138	n/a	msg, text = self._msgobj('msg_33.txt')
2139	n/a	self._idempotent(msg, text)
2140	n/a
2141	n/a	def test_text_plain_in_a_multipart_digest(self):
2142	n/a	msg, text = self._msgobj('msg_34.txt')
2143	n/a	self._idempotent(msg, text)
2144	n/a
2145	n/a	def test_nested_multipart_mixeds(self):
2146	n/a	msg, text = self._msgobj('msg_12a.txt')
2147	n/a	self._idempotent(msg, text)
2148	n/a
2149	n/a	def test_message_external_body_idempotent(self):
2150	n/a	msg, text = self._msgobj('msg_36.txt')
2151	n/a	self._idempotent(msg, text)
2152	n/a
2153	n/a	def test_message_delivery_status(self):
2154	n/a	msg, text = self._msgobj('msg_43.txt')
2155	n/a	self._idempotent(msg, text, unixfrom=True)
2156	n/a
2157	n/a	def test_message_signed_idempotent(self):
2158	n/a	msg, text = self._msgobj('msg_45.txt')
2159	n/a	self._idempotent(msg, text)
2160	n/a
2161	n/a	def test_content_type(self):
2162	n/a	eq = self.assertEqual
2163	n/a	unless = self.assertTrue
2164	n/a	# Get a message object and reset the seek pointer for other tests
2165	n/a	msg, text = self._msgobj('msg_05.txt')
2166	n/a	eq(msg.get_content_type(), 'multipart/report')
2167	n/a	# Test the Content-Type: parameters
2168	n/a	params = {}
2169	n/a	for pk, pv in msg.get_params():
2170	n/a	params[pk] = pv
2171	n/a	eq(params['report-type'], 'delivery-status')
2172	n/a	eq(params['boundary'], 'D1690A7AC1.996856090/mail.example.com')
2173	n/a	eq(msg.preamble, 'This is a MIME-encapsulated message.' + self.linesep)
2174	n/a	eq(msg.epilogue, self.linesep)
2175	n/a	eq(len(msg.get_payload()), 3)
2176	n/a	# Make sure the subparts are what we expect
2177	n/a	msg1 = msg.get_payload(0)
2178	n/a	eq(msg1.get_content_type(), 'text/plain')
2179	n/a	eq(msg1.get_payload(), 'Yadda yadda yadda' + self.linesep)
2180	n/a	msg2 = msg.get_payload(1)
2181	n/a	eq(msg2.get_content_type(), 'text/plain')
2182	n/a	eq(msg2.get_payload(), 'Yadda yadda yadda' + self.linesep)
2183	n/a	msg3 = msg.get_payload(2)
2184	n/a	eq(msg3.get_content_type(), 'message/rfc822')
2185	n/a	self.assertTrue(isinstance(msg3, Message))
2186	n/a	payload = msg3.get_payload()
2187	n/a	unless(isinstance(payload, list))
2188	n/a	eq(len(payload), 1)
2189	n/a	msg4 = payload[0]
2190	n/a	unless(isinstance(msg4, Message))
2191	n/a	eq(msg4.get_payload(), 'Yadda yadda yadda' + self.linesep)
2192	n/a
2193	n/a	def test_parser(self):
2194	n/a	eq = self.assertEqual
2195	n/a	unless = self.assertTrue
2196	n/a	msg, text = self._msgobj('msg_06.txt')
2197	n/a	# Check some of the outer headers
2198	n/a	eq(msg.get_content_type(), 'message/rfc822')
2199	n/a	# Make sure the payload is a list of exactly one sub-Message, and that
2200	n/a	# that submessage has a type of text/plain
2201	n/a	payload = msg.get_payload()
2202	n/a	unless(isinstance(payload, list))
2203	n/a	eq(len(payload), 1)
2204	n/a	msg1 = payload[0]
2205	n/a	self.assertTrue(isinstance(msg1, Message))
2206	n/a	eq(msg1.get_content_type(), 'text/plain')
2207	n/a	self.assertTrue(isinstance(msg1.get_payload(), str))
2208	n/a	eq(msg1.get_payload(), self.linesep)
2209	n/a
2210	n/a
2211	n/a
2212	n/a	# Test various other bits of the package's functionality
2213	n/a	class TestMiscellaneous(TestEmailBase):
2214	n/a	def test_message_from_string(self):
2215	n/a	with openfile('msg_01.txt') as fp:
2216	n/a	text = fp.read()
2217	n/a	msg = email.message_from_string(text)
2218	n/a	s = StringIO()
2219	n/a	# Don't wrap/continue long headers since we're trying to test
2220	n/a	# idempotency.
2221	n/a	g = Generator(s, maxheaderlen=0)
2222	n/a	g.flatten(msg)
2223	n/a	self.assertEqual(text, s.getvalue())
2224	n/a
2225	n/a	def test_message_from_file(self):
2226	n/a	with openfile('msg_01.txt') as fp:
2227	n/a	text = fp.read()
2228	n/a	fp.seek(0)
2229	n/a	msg = email.message_from_file(fp)
2230	n/a	s = StringIO()
2231	n/a	# Don't wrap/continue long headers since we're trying to test
2232	n/a	# idempotency.
2233	n/a	g = Generator(s, maxheaderlen=0)
2234	n/a	g.flatten(msg)
2235	n/a	self.assertEqual(text, s.getvalue())
2236	n/a
2237	n/a	def test_message_from_string_with_class(self):
2238	n/a	unless = self.assertTrue
2239	n/a	with openfile('msg_01.txt') as fp:
2240	n/a	text = fp.read()
2241	n/a
2242	n/a	# Create a subclass
2243	n/a	class MyMessage(Message):
2244	n/a	pass
2245	n/a
2246	n/a	msg = email.message_from_string(text, MyMessage)
2247	n/a	unless(isinstance(msg, MyMessage))
2248	n/a	# Try something more complicated
2249	n/a	with openfile('msg_02.txt') as fp:
2250	n/a	text = fp.read()
2251	n/a	msg = email.message_from_string(text, MyMessage)
2252	n/a	for subpart in msg.walk():
2253	n/a	unless(isinstance(subpart, MyMessage))
2254	n/a
2255	n/a	def test_message_from_file_with_class(self):
2256	n/a	unless = self.assertTrue
2257	n/a	# Create a subclass
2258	n/a	class MyMessage(Message):
2259	n/a	pass
2260	n/a
2261	n/a	with openfile('msg_01.txt') as fp:
2262	n/a	msg = email.message_from_file(fp, MyMessage)
2263	n/a	unless(isinstance(msg, MyMessage))
2264	n/a	# Try something more complicated
2265	n/a	with openfile('msg_02.txt') as fp:
2266	n/a	msg = email.message_from_file(fp, MyMessage)
2267	n/a	for subpart in msg.walk():
2268	n/a	unless(isinstance(subpart, MyMessage))
2269	n/a
2270	n/a	def test__all__(self):
2271	n/a	module = __import__('email')
2272	n/a	# Can't use sorted() here due to Python 2.3 compatibility
2273	n/a	all = module.__all__[:]
2274	n/a	all.sort()
2275	n/a	self.assertEqual(all, [
2276	n/a	'base64mime', 'charset', 'encoders', 'errors', 'generator',
2277	n/a	'header', 'iterators', 'message', 'message_from_binary_file',
2278	n/a	'message_from_bytes', 'message_from_file',
2279	n/a	'message_from_string', 'mime', 'parser',
2280	n/a	'quoprimime', 'utils',
2281	n/a	])
2282	n/a
2283	n/a	def test_formatdate(self):
2284	n/a	now = time.time()
2285	n/a	self.assertEqual(utils.parsedate(utils.formatdate(now))[:6],
2286	n/a	time.gmtime(now)[:6])
2287	n/a
2288	n/a	def test_formatdate_localtime(self):
2289	n/a	now = time.time()
2290	n/a	self.assertEqual(
2291	n/a	utils.parsedate(utils.formatdate(now, localtime=True))[:6],
2292	n/a	time.localtime(now)[:6])
2293	n/a
2294	n/a	def test_formatdate_usegmt(self):
2295	n/a	now = time.time()
2296	n/a	self.assertEqual(
2297	n/a	utils.formatdate(now, localtime=False),
2298	n/a	time.strftime('%a, %d %b %Y %H:%M:%S -0000', time.gmtime(now)))
2299	n/a	self.assertEqual(
2300	n/a	utils.formatdate(now, localtime=False, usegmt=True),
2301	n/a	time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime(now)))
2302	n/a
2303	n/a	def test_parsedate_none(self):
2304	n/a	self.assertEqual(utils.parsedate(''), None)
2305	n/a
2306	n/a	def test_parsedate_compact(self):
2307	n/a	# The FWS after the comma is optional
2308	n/a	self.assertEqual(utils.parsedate('Wed,3 Apr 2002 14:58:26 +0800'),
2309	n/a	utils.parsedate('Wed, 3 Apr 2002 14:58:26 +0800'))
2310	n/a
2311	n/a	def test_parsedate_no_dayofweek(self):
2312	n/a	eq = self.assertEqual
2313	n/a	eq(utils.parsedate_tz('25 Feb 2003 13:47:26 -0800'),
2314	n/a	(2003, 2, 25, 13, 47, 26, 0, 1, -1, -28800))
2315	n/a
2316	n/a	def test_parsedate_compact_no_dayofweek(self):
2317	n/a	eq = self.assertEqual
2318	n/a	eq(utils.parsedate_tz('5 Feb 2003 13:47:26 -0800'),
2319	n/a	(2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
2320	n/a
2321	n/a	def test_parsedate_no_space_before_positive_offset(self):
2322	n/a	self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26+0800'),
2323	n/a	(2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
2324	n/a
2325	n/a	def test_parsedate_no_space_before_negative_offset(self):
2326	n/a	# Issue 1155362: we already handled '+' for this case.
2327	n/a	self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26-0800'),
2328	n/a	(2002, 4, 3, 14, 58, 26, 0, 1, -1, -28800))
2329	n/a
2330	n/a
2331	n/a	def test_parsedate_acceptable_to_time_functions(self):
2332	n/a	eq = self.assertEqual
2333	n/a	timetup = utils.parsedate('5 Feb 2003 13:47:26 -0800')
2334	n/a	t = int(time.mktime(timetup))
2335	n/a	eq(time.localtime(t)[:6], timetup[:6])
2336	n/a	eq(int(time.strftime('%Y', timetup)), 2003)
2337	n/a	timetup = utils.parsedate_tz('5 Feb 2003 13:47:26 -0800')
2338	n/a	t = int(time.mktime(timetup[:9]))
2339	n/a	eq(time.localtime(t)[:6], timetup[:6])
2340	n/a	eq(int(time.strftime('%Y', timetup[:9])), 2003)
2341	n/a
2342	n/a	def test_parsedate_y2k(self):
2343	n/a	"""Test for parsing a date with a two-digit year.
2344	n/a
2345	n/a	Parsing a date with a two-digit year should return the correct
2346	n/a	four-digit year. RFC822 allows two-digit years, but RFC2822 (which
2347	n/a	obsoletes RFC822) requires four-digit years.
2348	n/a
2349	n/a	"""
2350	n/a	self.assertEqual(utils.parsedate_tz('25 Feb 03 13:47:26 -0800'),
2351	n/a	utils.parsedate_tz('25 Feb 2003 13:47:26 -0800'))
2352	n/a	self.assertEqual(utils.parsedate_tz('25 Feb 71 13:47:26 -0800'),
2353	n/a	utils.parsedate_tz('25 Feb 1971 13:47:26 -0800'))
2354	n/a
2355	n/a	def test_parseaddr_empty(self):
2356	n/a	self.assertEqual(utils.parseaddr('<>'), ('', ''))
2357	n/a	self.assertEqual(utils.formataddr(utils.parseaddr('<>')), '')
2358	n/a
2359	n/a	def test_noquote_dump(self):
2360	n/a	self.assertEqual(
2361	n/a	utils.formataddr(('A Silly Person', 'person@dom.ain')),
2362	n/a	'A Silly Person <person@dom.ain>')
2363	n/a
2364	n/a	def test_escape_dump(self):
2365	n/a	self.assertEqual(
2366	n/a	utils.formataddr(('A (Very) Silly Person', 'person@dom.ain')),
2367	n/a	r'"A $Very$ Silly Person" <person@dom.ain>')
2368	n/a	a = r'A $Special$ Person'
2369	n/a	b = 'person@dom.ain'
2370	n/a	self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
2371	n/a
2372	n/a	def test_escape_backslashes(self):
2373	n/a	self.assertEqual(
2374	n/a	utils.formataddr(('Arthur \Backslash\ Foobar', 'person@dom.ain')),
2375	n/a	r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>')
2376	n/a	a = r'Arthur \Backslash\ Foobar'
2377	n/a	b = 'person@dom.ain'
2378	n/a	self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
2379	n/a
2380	n/a	def test_name_with_dot(self):
2381	n/a	x = 'John X. Doe <jxd@example.com>'
2382	n/a	y = '"John X. Doe" <jxd@example.com>'
2383	n/a	a, b = ('John X. Doe', 'jxd@example.com')
2384	n/a	self.assertEqual(utils.parseaddr(x), (a, b))
2385	n/a	self.assertEqual(utils.parseaddr(y), (a, b))
2386	n/a	# formataddr() quotes the name if there's a dot in it
2387	n/a	self.assertEqual(utils.formataddr((a, b)), y)
2388	n/a
2389	n/a	def test_parseaddr_preserves_quoted_pairs_in_addresses(self):
2390	n/a	# issue 10005. Note that in the third test the second pair of
2391	n/a	# backslashes is not actually a quoted pair because it is not inside a
2392	n/a	# comment or quoted string: the address being parsed has a quoted
2393	n/a	# string containing a quoted backslash, followed by 'example' and two
2394	n/a	# backslashes, followed by another quoted string containing a space and
2395	n/a	# the word 'example'. parseaddr copies those two backslashes
2396	n/a	# literally. Per rfc5322 this is not technically correct since a \ may
2397	n/a	# not appear in an address outside of a quoted string. It is probably
2398	n/a	# a sensible Postel interpretation, though.
2399	n/a	eq = self.assertEqual
2400	n/a	eq(utils.parseaddr('""example" example"@example.com'),
2401	n/a	('', '""example" example"@example.com'))
2402	n/a	eq(utils.parseaddr('"\\"example\\" example"@example.com'),
2403	n/a	('', '"\\"example\\" example"@example.com'))
2404	n/a	eq(utils.parseaddr('"\\\\"example\\\\" example"@example.com'),
2405	n/a	('', '"\\\\"example\\\\" example"@example.com'))
2406	n/a
2407	n/a	def test_parseaddr_preserves_spaces_in_local_part(self):
2408	n/a	# issue 9286. A normal RFC5322 local part should not contain any
2409	n/a	# folding white space, but legacy local parts can (they are a sequence
2410	n/a	# of atoms, not dotatoms). On the other hand we strip whitespace from
2411	n/a	# before the @ and around dots, on the assumption that the whitespace
2412	n/a	# around the punctuation is a mistake in what would otherwise be
2413	n/a	# an RFC5322 local part. Leading whitespace is, usual, stripped as well.
2414	n/a	self.assertEqual(('', "merwok wok@xample.com"),
2415	n/a	utils.parseaddr("merwok wok@xample.com"))
2416	n/a	self.assertEqual(('', "merwok wok@xample.com"),
2417	n/a	utils.parseaddr("merwok wok@xample.com"))
2418	n/a	self.assertEqual(('', "merwok wok@xample.com"),
2419	n/a	utils.parseaddr(" merwok wok @xample.com"))
2420	n/a	self.assertEqual(('', 'merwok"wok" wok@xample.com'),
2421	n/a	utils.parseaddr('merwok"wok" wok@xample.com'))
2422	n/a	self.assertEqual(('', 'merwok.wok.wok@xample.com'),
2423	n/a	utils.parseaddr('merwok. wok . wok@xample.com'))
2424	n/a
2425	n/a	def test_multiline_from_comment(self):
2426	n/a	x = """\
2427	n/a	Foo
2428	n/a	\tBar <foo@example.com>"""
2429	n/a	self.assertEqual(utils.parseaddr(x), ('Foo Bar', 'foo@example.com'))
2430	n/a
2431	n/a	def test_quote_dump(self):
2432	n/a	self.assertEqual(
2433	n/a	utils.formataddr(('A Silly; Person', 'person@dom.ain')),
2434	n/a	r'"A Silly; Person" <person@dom.ain>')
2435	n/a
2436	n/a	def test_charset_richcomparisons(self):
2437	n/a	eq = self.assertEqual
2438	n/a	ne = self.assertNotEqual
2439	n/a	cset1 = Charset()
2440	n/a	cset2 = Charset()
2441	n/a	eq(cset1, 'us-ascii')
2442	n/a	eq(cset1, 'US-ASCII')
2443	n/a	eq(cset1, 'Us-AsCiI')
2444	n/a	eq('us-ascii', cset1)
2445	n/a	eq('US-ASCII', cset1)
2446	n/a	eq('Us-AsCiI', cset1)
2447	n/a	ne(cset1, 'usascii')
2448	n/a	ne(cset1, 'USASCII')
2449	n/a	ne(cset1, 'UsAsCiI')
2450	n/a	ne('usascii', cset1)
2451	n/a	ne('USASCII', cset1)
2452	n/a	ne('UsAsCiI', cset1)
2453	n/a	eq(cset1, cset2)
2454	n/a	eq(cset2, cset1)
2455	n/a
2456	n/a	def test_getaddresses(self):
2457	n/a	eq = self.assertEqual
2458	n/a	eq(utils.getaddresses(['aperson@dom.ain (Al Person)',
2459	n/a	'Bud Person <bperson@dom.ain>']),
2460	n/a	[('Al Person', 'aperson@dom.ain'),
2461	n/a	('Bud Person', 'bperson@dom.ain')])
2462	n/a
2463	n/a	def test_getaddresses_nasty(self):
2464	n/a	eq = self.assertEqual
2465	n/a	eq(utils.getaddresses(['foo: ;']), [('', '')])
2466	n/a	eq(utils.getaddresses(
2467	n/a	['[]*-- =~$']),
2468	n/a	[('', ''), ('', ''), ('', '*--')])
2469	n/a	eq(utils.getaddresses(
2470	n/a	['foo: ;', '"Jason R. Mastaler" <jason@dom.ain>']),
2471	n/a	[('', ''), ('Jason R. Mastaler', 'jason@dom.ain')])
2472	n/a
2473	n/a	def test_getaddresses_embedded_comment(self):
2474	n/a	"""Test proper handling of a nested comment"""
2475	n/a	eq = self.assertEqual
2476	n/a	addrs = utils.getaddresses(['User ((nested comment)) <foo@bar.com>'])
2477	n/a	eq(addrs[0][1], 'foo@bar.com')
2478	n/a
2479	n/a	def test_utils_quote_unquote(self):
2480	n/a	eq = self.assertEqual
2481	n/a	msg = Message()
2482	n/a	msg.add_header('content-disposition', 'attachment',
2483	n/a	filename='foo\\wacky"name')
2484	n/a	eq(msg.get_filename(), 'foo\\wacky"name')
2485	n/a
2486	n/a	def test_get_body_encoding_with_bogus_charset(self):
2487	n/a	charset = Charset('not a charset')
2488	n/a	self.assertEqual(charset.get_body_encoding(), 'base64')
2489	n/a
2490	n/a	def test_get_body_encoding_with_uppercase_charset(self):
2491	n/a	eq = self.assertEqual
2492	n/a	msg = Message()
2493	n/a	msg['Content-Type'] = 'text/plain; charset=UTF-8'
2494	n/a	eq(msg['content-type'], 'text/plain; charset=UTF-8')
2495	n/a	charsets = msg.get_charsets()
2496	n/a	eq(len(charsets), 1)
2497	n/a	eq(charsets[0], 'utf-8')
2498	n/a	charset = Charset(charsets[0])
2499	n/a	eq(charset.get_body_encoding(), 'base64')
2500	n/a	msg.set_payload(b'hello world', charset=charset)
2501	n/a	eq(msg.get_payload(), 'aGVsbG8gd29ybGQ=\n')
2502	n/a	eq(msg.get_payload(decode=True), b'hello world')
2503	n/a	eq(msg['content-transfer-encoding'], 'base64')
2504	n/a	# Try another one
2505	n/a	msg = Message()
2506	n/a	msg['Content-Type'] = 'text/plain; charset="US-ASCII"'
2507	n/a	charsets = msg.get_charsets()
2508	n/a	eq(len(charsets), 1)
2509	n/a	eq(charsets[0], 'us-ascii')
2510	n/a	charset = Charset(charsets[0])
2511	n/a	eq(charset.get_body_encoding(), encoders.encode_7or8bit)
2512	n/a	msg.set_payload('hello world', charset=charset)
2513	n/a	eq(msg.get_payload(), 'hello world')
2514	n/a	eq(msg['content-transfer-encoding'], '7bit')
2515	n/a
2516	n/a	def test_charsets_case_insensitive(self):
2517	n/a	lc = Charset('us-ascii')
2518	n/a	uc = Charset('US-ASCII')
2519	n/a	self.assertEqual(lc.get_body_encoding(), uc.get_body_encoding())
2520	n/a
2521	n/a	def test_partial_falls_inside_message_delivery_status(self):
2522	n/a	eq = self.ndiffAssertEqual
2523	n/a	# The Parser interface provides chunks of data to FeedParser in 8192
2524	n/a	# byte gulps. SF bug #1076485 found one of those chunks inside
2525	n/a	# message/delivery-status header block, which triggered an
2526	n/a	# unreadline() of NeedMoreData.
2527	n/a	msg = self._msgobj('msg_43.txt')
2528	n/a	sfp = StringIO()
2529	n/a	iterators._structure(msg, sfp)
2530	n/a	eq(sfp.getvalue(), """\
2531	n/a	multipart/report
2532	n/a	text/plain
2533	n/a	message/delivery-status
2534	n/a	text/plain
2535	n/a	text/plain
2536	n/a	text/plain
2537	n/a	text/plain
2538	n/a	text/plain
2539	n/a	text/plain
2540	n/a	text/plain
2541	n/a	text/plain
2542	n/a	text/plain
2543	n/a	text/plain
2544	n/a	text/plain
2545	n/a	text/plain
2546	n/a	text/plain
2547	n/a	text/plain
2548	n/a	text/plain
2549	n/a	text/plain
2550	n/a	text/plain
2551	n/a	text/plain
2552	n/a	text/plain
2553	n/a	text/plain
2554	n/a	text/plain
2555	n/a	text/plain
2556	n/a	text/plain
2557	n/a	text/plain
2558	n/a	text/plain
2559	n/a	text/plain
2560	n/a	text/rfc822-headers
2561	n/a	""")
2562	n/a
2563	n/a	def test_make_msgid_domain(self):
2564	n/a	self.assertEqual(
2565	n/a	email.utils.make_msgid(domain='testdomain-string')[-19:],
2566	n/a	'@testdomain-string>')
2567	n/a
2568	n/a
2569	n/a	# Test the iterator/generators
2570	n/a	class TestIterators(TestEmailBase):
2571	n/a	def test_body_line_iterator(self):
2572	n/a	eq = self.assertEqual
2573	n/a	neq = self.ndiffAssertEqual
2574	n/a	# First a simple non-multipart message
2575	n/a	msg = self._msgobj('msg_01.txt')
2576	n/a	it = iterators.body_line_iterator(msg)
2577	n/a	lines = list(it)
2578	n/a	eq(len(lines), 6)
2579	n/a	neq(EMPTYSTRING.join(lines), msg.get_payload())
2580	n/a	# Now a more complicated multipart
2581	n/a	msg = self._msgobj('msg_02.txt')
2582	n/a	it = iterators.body_line_iterator(msg)
2583	n/a	lines = list(it)
2584	n/a	eq(len(lines), 43)
2585	n/a	with openfile('msg_19.txt') as fp:
2586	n/a	neq(EMPTYSTRING.join(lines), fp.read())
2587	n/a
2588	n/a	def test_typed_subpart_iterator(self):
2589	n/a	eq = self.assertEqual
2590	n/a	msg = self._msgobj('msg_04.txt')
2591	n/a	it = iterators.typed_subpart_iterator(msg, 'text')
2592	n/a	lines = []
2593	n/a	subparts = 0
2594	n/a	for subpart in it:
2595	n/a	subparts += 1
2596	n/a	lines.append(subpart.get_payload())
2597	n/a	eq(subparts, 2)
2598	n/a	eq(EMPTYSTRING.join(lines), """\
2599	n/a	a simple kind of mirror
2600	n/a	to reflect upon our own
2601	n/a	a simple kind of mirror
2602	n/a	to reflect upon our own
2603	n/a	""")
2604	n/a
2605	n/a	def test_typed_subpart_iterator_default_type(self):
2606	n/a	eq = self.assertEqual
2607	n/a	msg = self._msgobj('msg_03.txt')
2608	n/a	it = iterators.typed_subpart_iterator(msg, 'text', 'plain')
2609	n/a	lines = []
2610	n/a	subparts = 0
2611	n/a	for subpart in it:
2612	n/a	subparts += 1
2613	n/a	lines.append(subpart.get_payload())
2614	n/a	eq(subparts, 1)
2615	n/a	eq(EMPTYSTRING.join(lines), """\
2616	n/a
2617	n/a	Hi,
2618	n/a
2619	n/a	Do you like this message?
2620	n/a
2621	n/a	-Me
2622	n/a	""")
2623	n/a
2624	n/a	def test_pushCR_LF(self):
2625	n/a	'''FeedParser BufferedSubFile.push() assumed it received complete
2626	n/a	line endings. A CR ending one push() followed by a LF starting
2627	n/a	the next push() added an empty line.
2628	n/a	'''
2629	n/a	imt = [
2630	n/a	("a\r \n", 2),
2631	n/a	("b", 0),
2632	n/a	("c\n", 1),
2633	n/a	("", 0),
2634	n/a	("d\r\n", 1),
2635	n/a	("e\r", 0),
2636	n/a	("\nf", 1),
2637	n/a	("\r\n", 1),
2638	n/a	]
2639	n/a	from email.feedparser import BufferedSubFile, NeedMoreData
2640	n/a	bsf = BufferedSubFile()
2641	n/a	om = []
2642	n/a	nt = 0
2643	n/a	for il, n in imt:
2644	n/a	bsf.push(il)
2645	n/a	nt += n
2646	n/a	n1 = 0
2647	n/a	while True:
2648	n/a	ol = bsf.readline()
2649	n/a	if ol == NeedMoreData:
2650	n/a	break
2651	n/a	om.append(ol)
2652	n/a	n1 += 1
2653	n/a	self.assertTrue(n == n1)
2654	n/a	self.assertTrue(len(om) == nt)
2655	n/a	self.assertTrue(''.join([il for il, n in imt]) == ''.join(om))
2656	n/a
2657	n/a
2658	n/a
2659	n/a	class TestParsers(TestEmailBase):
2660	n/a	def test_header_parser(self):
2661	n/a	eq = self.assertEqual
2662	n/a	# Parse only the headers of a complex multipart MIME document
2663	n/a	with openfile('msg_02.txt') as fp:
2664	n/a	msg = HeaderParser().parse(fp)
2665	n/a	eq(msg['from'], 'ppp-request@zzz.org')
2666	n/a	eq(msg['to'], 'ppp@zzz.org')
2667	n/a	eq(msg.get_content_type(), 'multipart/mixed')
2668	n/a	self.assertFalse(msg.is_multipart())
2669	n/a	self.assertTrue(isinstance(msg.get_payload(), str))
2670	n/a
2671	n/a	def test_whitespace_continuation(self):
2672	n/a	eq = self.assertEqual
2673	n/a	# This message contains a line after the Subject: header that has only
2674	n/a	# whitespace, but it is not empty!
2675	n/a	msg = email.message_from_string("""\
2676	n/a	From: aperson@dom.ain
2677	n/a	To: bperson@dom.ain
2678	n/a	Subject: the next line has a space on it
2679	n/a	\x20
2680	n/a	Date: Mon, 8 Apr 2002 15:09:19 -0400
2681	n/a	Message-ID: spam
2682	n/a
2683	n/a	Here's the message body
2684	n/a	""")
2685	n/a	eq(msg['subject'], 'the next line has a space on it\n ')
2686	n/a	eq(msg['message-id'], 'spam')
2687	n/a	eq(msg.get_payload(), "Here's the message body\n")
2688	n/a
2689	n/a	def test_whitespace_continuation_last_header(self):
2690	n/a	eq = self.assertEqual
2691	n/a	# Like the previous test, but the subject line is the last
2692	n/a	# header.
2693	n/a	msg = email.message_from_string("""\
2694	n/a	From: aperson@dom.ain
2695	n/a	To: bperson@dom.ain
2696	n/a	Date: Mon, 8 Apr 2002 15:09:19 -0400
2697	n/a	Message-ID: spam
2698	n/a	Subject: the next line has a space on it
2699	n/a	\x20
2700	n/a
2701	n/a	Here's the message body
2702	n/a	""")
2703	n/a	eq(msg['subject'], 'the next line has a space on it\n ')
2704	n/a	eq(msg['message-id'], 'spam')
2705	n/a	eq(msg.get_payload(), "Here's the message body\n")
2706	n/a
2707	n/a	def test_crlf_separation(self):
2708	n/a	eq = self.assertEqual
2709	n/a	with openfile('msg_26.txt', newline='\n') as fp:
2710	n/a	msg = Parser().parse(fp)
2711	n/a	eq(len(msg.get_payload()), 2)
2712	n/a	part1 = msg.get_payload(0)
2713	n/a	eq(part1.get_content_type(), 'text/plain')
2714	n/a	eq(part1.get_payload(), 'Simple email with attachment.\r\n\r\n')
2715	n/a	part2 = msg.get_payload(1)
2716	n/a	eq(part2.get_content_type(), 'application/riscos')
2717	n/a
2718	n/a	def test_crlf_flatten(self):
2719	n/a	# Using newline='\n' preserves the crlfs in this input file.
2720	n/a	with openfile('msg_26.txt', newline='\n') as fp:
2721	n/a	text = fp.read()
2722	n/a	msg = email.message_from_string(text)
2723	n/a	s = StringIO()
2724	n/a	g = Generator(s)
2725	n/a	g.flatten(msg, linesep='\r\n')
2726	n/a	self.assertEqual(s.getvalue(), text)
2727	n/a
2728	n/a	maxDiff = None
2729	n/a
2730	n/a	def test_multipart_digest_with_extra_mime_headers(self):
2731	n/a	eq = self.assertEqual
2732	n/a	neq = self.ndiffAssertEqual
2733	n/a	with openfile('msg_28.txt') as fp:
2734	n/a	msg = email.message_from_file(fp)
2735	n/a	# Structure is:
2736	n/a	# multipart/digest
2737	n/a	# message/rfc822
2738	n/a	# text/plain
2739	n/a	# message/rfc822
2740	n/a	# text/plain
2741	n/a	eq(msg.is_multipart(), 1)
2742	n/a	eq(len(msg.get_payload()), 2)
2743	n/a	part1 = msg.get_payload(0)
2744	n/a	eq(part1.get_content_type(), 'message/rfc822')
2745	n/a	eq(part1.is_multipart(), 1)
2746	n/a	eq(len(part1.get_payload()), 1)
2747	n/a	part1a = part1.get_payload(0)
2748	n/a	eq(part1a.is_multipart(), 0)
2749	n/a	eq(part1a.get_content_type(), 'text/plain')
2750	n/a	neq(part1a.get_payload(), 'message 1\n')
2751	n/a	# next message/rfc822
2752	n/a	part2 = msg.get_payload(1)
2753	n/a	eq(part2.get_content_type(), 'message/rfc822')
2754	n/a	eq(part2.is_multipart(), 1)
2755	n/a	eq(len(part2.get_payload()), 1)
2756	n/a	part2a = part2.get_payload(0)
2757	n/a	eq(part2a.is_multipart(), 0)
2758	n/a	eq(part2a.get_content_type(), 'text/plain')
2759	n/a	neq(part2a.get_payload(), 'message 2\n')
2760	n/a
2761	n/a	def test_three_lines(self):
2762	n/a	# A bug report by Andrew McNamara
2763	n/a	lines = ['From: Andrew Person <aperson@dom.ain',
2764	n/a	'Subject: Test',
2765	n/a	'Date: Tue, 20 Aug 2002 16:43:45 +1000']
2766	n/a	msg = email.message_from_string(NL.join(lines))
2767	n/a	self.assertEqual(msg['date'], 'Tue, 20 Aug 2002 16:43:45 +1000')
2768	n/a
2769	n/a	def test_strip_line_feed_and_carriage_return_in_headers(self):
2770	n/a	eq = self.assertEqual
2771	n/a	# For [ 1002475 ] email message parser doesn't handle \r\n correctly
2772	n/a	value1 = 'text'
2773	n/a	value2 = 'more text'
2774	n/a	m = 'Header: %s\r\nNext-Header: %s\r\n\r\nBody\r\n\r\n' % (
2775	n/a	value1, value2)
2776	n/a	msg = email.message_from_string(m)
2777	n/a	eq(msg.get('Header'), value1)
2778	n/a	eq(msg.get('Next-Header'), value2)
2779	n/a
2780	n/a	def test_rfc2822_header_syntax(self):
2781	n/a	eq = self.assertEqual
2782	n/a	m = '>From: foo\nFrom: bar\n!"#QUX;~: zoo\n\nbody'
2783	n/a	msg = email.message_from_string(m)
2784	n/a	eq(len(msg), 3)
2785	n/a	eq(sorted(field for field in msg), ['!"#QUX;~', '>From', 'From'])
2786	n/a	eq(msg.get_payload(), 'body')
2787	n/a
2788	n/a	def test_rfc2822_space_not_allowed_in_header(self):
2789	n/a	eq = self.assertEqual
2790	n/a	m = '>From foo@example.com 11:25:53\nFrom: bar\n!"#QUX;~: zoo\n\nbody'
2791	n/a	msg = email.message_from_string(m)
2792	n/a	eq(len(msg.keys()), 0)
2793	n/a
2794	n/a	def test_rfc2822_one_character_header(self):
2795	n/a	eq = self.assertEqual
2796	n/a	m = 'A: first header\nB: second header\nCC: third header\n\nbody'
2797	n/a	msg = email.message_from_string(m)
2798	n/a	headers = msg.keys()
2799	n/a	headers.sort()
2800	n/a	eq(headers, ['A', 'B', 'CC'])
2801	n/a	eq(msg.get_payload(), 'body')
2802	n/a
2803	n/a	def test_CRLFLF_at_end_of_part(self):
2804	n/a	# issue 5610: feedparser should not eat two chars from body part ending
2805	n/a	# with "\r\n\n".
2806	n/a	m = (
2807	n/a	"From: foo@bar.com\n"
2808	n/a	"To: baz\n"
2809	n/a	"Mime-Version: 1.0\n"
2810	n/a	"Content-Type: multipart/mixed; boundary=BOUNDARY\n"
2811	n/a	"\n"
2812	n/a	"--BOUNDARY\n"
2813	n/a	"Content-Type: text/plain\n"
2814	n/a	"\n"
2815	n/a	"body ending with CRLF newline\r\n"
2816	n/a	"\n"
2817	n/a	"--BOUNDARY--\n"
2818	n/a	)
2819	n/a	msg = email.message_from_string(m)
2820	n/a	self.assertTrue(msg.get_payload(0).get_payload().endswith('\r\n'))
2821	n/a
2822	n/a
2823	n/a	class Test8BitBytesHandling(unittest.TestCase):
2824	n/a	# In Python3 all input is string, but that doesn't work if the actual input
2825	n/a	# uses an 8bit transfer encoding. To hack around that, in email 5.1 we
2826	n/a	# decode byte streams using the surrogateescape error handler, and
2827	n/a	# reconvert to binary at appropriate places if we detect surrogates. This
2828	n/a	# doesn't allow us to transform headers with 8bit bytes (they get munged),
2829	n/a	# but it does allow us to parse and preserve them, and to decode body
2830	n/a	# parts that use an 8bit CTE.
2831	n/a
2832	n/a	bodytest_msg = textwrap.dedent("""\
2833	n/a	From: foo@bar.com
2834	n/a	To: baz
2835	n/a	Mime-Version: 1.0
2836	n/a	Content-Type: text/plain; charset={charset}
2837	n/a	Content-Transfer-Encoding: {cte}
2838	n/a
2839	n/a	{bodyline}
2840	n/a	""")
2841	n/a
2842	n/a	def test_known_8bit_CTE(self):
2843	n/a	m = self.bodytest_msg.format(charset='utf-8',
2844	n/a	cte='8bit',
2845	n/a	bodyline='pÃ¶stal').encode('utf-8')
2846	n/a	msg = email.message_from_bytes(m)
2847	n/a	self.assertEqual(msg.get_payload(), "pÃ¶stal\n")
2848	n/a	self.assertEqual(msg.get_payload(decode=True),
2849	n/a	"pÃ¶stal\n".encode('utf-8'))
2850	n/a
2851	n/a	def test_unknown_8bit_CTE(self):
2852	n/a	m = self.bodytest_msg.format(charset='notavalidcharset',
2853	n/a	cte='8bit',
2854	n/a	bodyline='pÃ¶stal').encode('utf-8')
2855	n/a	msg = email.message_from_bytes(m)
2856	n/a	self.assertEqual(msg.get_payload(), "p\uFFFD\uFFFDstal\n")
2857	n/a	self.assertEqual(msg.get_payload(decode=True),
2858	n/a	"pÃ¶stal\n".encode('utf-8'))
2859	n/a
2860	n/a	def test_8bit_in_quopri_body(self):
2861	n/a	# This is non-RFC compliant data...without 'decode' the library code
2862	n/a	# decodes the body using the charset from the headers, and because the
2863	n/a	# source byte really is utf-8 this works. This is likely to fail
2864	n/a	# against real dirty data (ie: produce mojibake), but the data is
2865	n/a	# invalid anyway so it is as good a guess as any. But this means that
2866	n/a	# this test just confirms the current behavior; that behavior is not
2867	n/a	# necessarily the best possible behavior. With 'decode' it is
2868	n/a	# returning the raw bytes, so that test should be of correct behavior,
2869	n/a	# or at least produce the same result that email4 did.
2870	n/a	m = self.bodytest_msg.format(charset='utf-8',
2871	n/a	cte='quoted-printable',
2872	n/a	bodyline='p=C3=B6stÃ¡l').encode('utf-8')
2873	n/a	msg = email.message_from_bytes(m)
2874	n/a	self.assertEqual(msg.get_payload(), 'p=C3=B6stÃ¡l\n')
2875	n/a	self.assertEqual(msg.get_payload(decode=True),
2876	n/a	'pÃ¶stÃ¡l\n'.encode('utf-8'))
2877	n/a
2878	n/a	def test_invalid_8bit_in_non_8bit_cte_uses_replace(self):
2879	n/a	# This is similar to the previous test, but proves that if the 8bit
2880	n/a	# byte is undecodeable in the specified charset, it gets replaced
2881	n/a	# by the unicode 'unknown' character. Again, this may or may not
2882	n/a	# be the ideal behavior. Note that if decode=False none of the
2883	n/a	# decoders will get involved, so this is the only test we need
2884	n/a	# for this behavior.
2885	n/a	m = self.bodytest_msg.format(charset='ascii',
2886	n/a	cte='quoted-printable',
2887	n/a	bodyline='p=C3=B6stÃ¡l').encode('utf-8')
2888	n/a	msg = email.message_from_bytes(m)
2889	n/a	self.assertEqual(msg.get_payload(), 'p=C3=B6st\uFFFD\uFFFDl\n')
2890	n/a	self.assertEqual(msg.get_payload(decode=True),
2891	n/a	'pÃ¶stÃ¡l\n'.encode('utf-8'))
2892	n/a
2893	n/a	def test_8bit_in_base64_body(self):
2894	n/a	# Sticking an 8bit byte in a base64 block makes it undecodable by
2895	n/a	# normal means, so the block is returned undecoded, but as bytes.
2896	n/a	m = self.bodytest_msg.format(charset='utf-8',
2897	n/a	cte='base64',
2898	n/a	bodyline='cMO2c3RhbAÃ¡=').encode('utf-8')
2899	n/a	msg = email.message_from_bytes(m)
2900	n/a	self.assertEqual(msg.get_payload(decode=True),
2901	n/a	'cMO2c3RhbAÃ¡=\n'.encode('utf-8'))
2902	n/a
2903	n/a	def test_8bit_in_uuencode_body(self):
2904	n/a	# Sticking an 8bit byte in a uuencode block makes it undecodable by
2905	n/a	# normal means, so the block is returned undecoded, but as bytes.
2906	n/a	m = self.bodytest_msg.format(charset='utf-8',
2907	n/a	cte='uuencode',
2908	n/a	bodyline='<,.V<W1A; Ã¡ ').encode('utf-8')
2909	n/a	msg = email.message_from_bytes(m)
2910	n/a	self.assertEqual(msg.get_payload(decode=True),
2911	n/a	'<,.V<W1A; Ã¡ \n'.encode('utf-8'))
2912	n/a
2913	n/a
2914	n/a	headertest_headers = (
2915	n/a	('From: foo@bar.com', ('From', 'foo@bar.com')),
2916	n/a	('To: bÃ¡z', ('To', '=?unknown-8bit?q?b=C3=A1z?=')),
2917	n/a	('Subject: Maintenant je vous prÃ©sente mon collÃ¨gue, le pouf cÃ©lÃ¨bre\n'
2918	n/a	'\tJean de Baddie',
2919	n/a	('Subject', '=?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_'
2920	n/a	'coll=C3=A8gue=2C_le_pouf_c=C3=A9l=C3=A8bre?=\n'
2921	n/a	' =?unknown-8bit?q?_Jean_de_Baddie?=')),
2922	n/a	('From: gÃ¶st', ('From', '=?unknown-8bit?b?Z8O2c3Q=?=')),
2923	n/a	)
2924	n/a	headertest_msg = ('\n'.join([src for (src, _) in headertest_headers]) +
2925	n/a	'\nYes, they are flying.\n').encode('utf-8')
2926	n/a
2927	n/a	def test_get_8bit_header(self):
2928	n/a	msg = email.message_from_bytes(self.headertest_msg)
2929	n/a	self.assertEqual(str(msg.get('to')), 'b\uFFFD\uFFFDz')
2930	n/a	self.assertEqual(str(msg['to']), 'b\uFFFD\uFFFDz')
2931	n/a
2932	n/a	def test_print_8bit_headers(self):
2933	n/a	msg = email.message_from_bytes(self.headertest_msg)
2934	n/a	self.assertEqual(str(msg),
2935	n/a	textwrap.dedent("""\
2936	n/a	From: {}
2937	n/a	To: {}
2938	n/a	Subject: {}
2939	n/a	From: {}
2940	n/a
2941	n/a	Yes, they are flying.
2942	n/a	""").format(*[expected[1] for (_, expected) in
2943	n/a	self.headertest_headers]))
2944	n/a
2945	n/a	def test_values_with_8bit_headers(self):
2946	n/a	msg = email.message_from_bytes(self.headertest_msg)
2947	n/a	self.assertListEqual([str(x) for x in msg.values()],
2948	n/a	['foo@bar.com',
2949	n/a	'b\uFFFD\uFFFDz',
2950	n/a	'Maintenant je vous pr\uFFFD\uFFFDsente mon '
2951	n/a	'coll\uFFFD\uFFFDgue, le pouf '
2952	n/a	'c\uFFFD\uFFFDl\uFFFD\uFFFDbre\n'
2953	n/a	'\tJean de Baddie',
2954	n/a	"g\uFFFD\uFFFDst"])
2955	n/a
2956	n/a	def test_items_with_8bit_headers(self):
2957	n/a	msg = email.message_from_bytes(self.headertest_msg)
2958	n/a	self.assertListEqual([(str(x), str(y)) for (x, y) in msg.items()],
2959	n/a	[('From', 'foo@bar.com'),
2960	n/a	('To', 'b\uFFFD\uFFFDz'),
2961	n/a	('Subject', 'Maintenant je vous '
2962	n/a	'pr\uFFFD\uFFFDsente '
2963	n/a	'mon coll\uFFFD\uFFFDgue, le pouf '
2964	n/a	'c\uFFFD\uFFFDl\uFFFD\uFFFDbre\n'
2965	n/a	'\tJean de Baddie'),
2966	n/a	('From', 'g\uFFFD\uFFFDst')])
2967	n/a
2968	n/a	def test_get_all_with_8bit_headers(self):
2969	n/a	msg = email.message_from_bytes(self.headertest_msg)
2970	n/a	self.assertListEqual([str(x) for x in msg.get_all('from')],
2971	n/a	['foo@bar.com',
2972	n/a	'g\uFFFD\uFFFDst'])
2973	n/a
2974	n/a	non_latin_bin_msg = textwrap.dedent("""\
2975	n/a	From: foo@bar.com
2976	n/a	To: bÃ¡z
2977	n/a	Subject: Maintenant je vous prÃ©sente mon collÃ¨gue, le pouf cÃ©lÃ¨bre
2978	n/a	\tJean de Baddie
2979	n/a	Mime-Version: 1.0
2980	n/a	Content-Type: text/plain; charset="utf-8"
2981	n/a	Content-Transfer-Encoding: 8bit
2982	n/a
2983	n/a	Ð”Ð°, Ð¾Ð½Ð¸ Ð»ÐµÑ‚ÑÑ‚.
2984	n/a	""").encode('utf-8')
2985	n/a
2986	n/a	def test_bytes_generator(self):
2987	n/a	msg = email.message_from_bytes(self.non_latin_bin_msg)
2988	n/a	out = BytesIO()
2989	n/a	email.generator.BytesGenerator(out).flatten(msg)
2990	n/a	self.assertEqual(out.getvalue(), self.non_latin_bin_msg)
2991	n/a
2992	n/a	def test_bytes_generator_handles_None_body(self):
2993	n/a	#Issue 11019
2994	n/a	msg = email.message.Message()
2995	n/a	out = BytesIO()
2996	n/a	email.generator.BytesGenerator(out).flatten(msg)
2997	n/a	self.assertEqual(out.getvalue(), b"\n")
2998	n/a
2999	n/a	non_latin_bin_msg_as7bit_wrapped = textwrap.dedent("""\
3000	n/a	From: foo@bar.com
3001	n/a	To: =?unknown-8bit?q?b=C3=A1z?=
3002	n/a	Subject: =?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_coll=C3=A8gue?=
3003	n/a	=?unknown-8bit?q?=2C_le_pouf_c=C3=A9l=C3=A8bre?=
3004	n/a	=?unknown-8bit?q?_Jean_de_Baddie?=
3005	n/a	Mime-Version: 1.0
3006	n/a	Content-Type: text/plain; charset="utf-8"
3007	n/a	Content-Transfer-Encoding: base64
3008	n/a
3009	n/a	0JTQsCwg0L7QvdC4INC70LXRgtGP0YIuCg==
3010	n/a	""")
3011	n/a
3012	n/a	def test_generator_handles_8bit(self):
3013	n/a	msg = email.message_from_bytes(self.non_latin_bin_msg)
3014	n/a	out = StringIO()
3015	n/a	email.generator.Generator(out).flatten(msg)
3016	n/a	self.assertEqual(out.getvalue(), self.non_latin_bin_msg_as7bit_wrapped)
3017	n/a
3018	n/a	def test_bytes_generator_with_unix_from(self):
3019	n/a	# The unixfrom contains a current date, so we can't check it
3020	n/a	# literally. Just make sure the first word is 'From' and the
3021	n/a	# rest of the message matches the input.
3022	n/a	msg = email.message_from_bytes(self.non_latin_bin_msg)
3023	n/a	out = BytesIO()
3024	n/a	email.generator.BytesGenerator(out).flatten(msg, unixfrom=True)
3025	n/a	lines = out.getvalue().split(b'\n')
3026	n/a	self.assertEqual(lines[0].split()[0], b'From')
3027	n/a	self.assertEqual(b'\n'.join(lines[1:]), self.non_latin_bin_msg)
3028	n/a
3029	n/a	non_latin_bin_msg_as7bit = non_latin_bin_msg_as7bit_wrapped.split('\n')
3030	n/a	non_latin_bin_msg_as7bit[2:4] = [
3031	n/a	'Subject: =?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_'
3032	n/a	'coll=C3=A8gue=2C_le_pouf_c=C3=A9l=C3=A8bre?=']
3033	n/a	non_latin_bin_msg_as7bit = '\n'.join(non_latin_bin_msg_as7bit)
3034	n/a
3035	n/a	def test_message_from_binary_file(self):
3036	n/a	fn = 'test.msg'
3037	n/a	self.addCleanup(unlink, fn)
3038	n/a	with open(fn, 'wb') as testfile:
3039	n/a	testfile.write(self.non_latin_bin_msg)
3040	n/a	with open(fn, 'rb') as testfile:
3041	n/a	m = email.parser.BytesParser().parse(testfile)
3042	n/a	self.assertEqual(str(m), self.non_latin_bin_msg_as7bit)
3043	n/a
3044	n/a	latin_bin_msg = textwrap.dedent("""\
3045	n/a	From: foo@bar.com
3046	n/a	To: Dinsdale
3047	n/a	Subject: Nudge nudge, wink, wink
3048	n/a	Mime-Version: 1.0
3049	n/a	Content-Type: text/plain; charset="latin-1"
3050	n/a	Content-Transfer-Encoding: 8bit
3051	n/a
3052	n/a	oh lÃ lÃ , know what I mean, know what I mean?
3053	n/a	""").encode('latin-1')
3054	n/a
3055	n/a	latin_bin_msg_as7bit = textwrap.dedent("""\
3056	n/a	From: foo@bar.com
3057	n/a	To: Dinsdale
3058	n/a	Subject: Nudge nudge, wink, wink
3059	n/a	Mime-Version: 1.0
3060	n/a	Content-Type: text/plain; charset="iso-8859-1"
3061	n/a	Content-Transfer-Encoding: quoted-printable
3062	n/a
3063	n/a	oh l=E0 l=E0, know what I mean, know what I mean?
3064	n/a	""")
3065	n/a
3066	n/a	def test_string_generator_reencodes_to_quopri_when_appropriate(self):
3067	n/a	m = email.message_from_bytes(self.latin_bin_msg)
3068	n/a	self.assertEqual(str(m), self.latin_bin_msg_as7bit)
3069	n/a
3070	n/a	def test_decoded_generator_emits_unicode_body(self):
3071	n/a	m = email.message_from_bytes(self.latin_bin_msg)
3072	n/a	out = StringIO()
3073	n/a	email.generator.DecodedGenerator(out).flatten(m)
3074	n/a	#DecodedHeader output contains an extra blank line compared
3075	n/a	#to the input message. RDM: not sure if this is a bug or not,
3076	n/a	#but it is not specific to the 8bit->7bit conversion.
3077	n/a	self.assertEqual(out.getvalue(),
3078	n/a	self.latin_bin_msg.decode('latin-1')+'\n')
3079	n/a
3080	n/a	def test_bytes_feedparser(self):
3081	n/a	bfp = email.feedparser.BytesFeedParser()
3082	n/a	for i in range(0, len(self.latin_bin_msg), 10):
3083	n/a	bfp.feed(self.latin_bin_msg[i:i+10])
3084	n/a	m = bfp.close()
3085	n/a	self.assertEqual(str(m), self.latin_bin_msg_as7bit)
3086	n/a
3087	n/a	def test_crlf_flatten(self):
3088	n/a	with openfile('msg_26.txt', 'rb') as fp:
3089	n/a	text = fp.read()
3090	n/a	msg = email.message_from_bytes(text)
3091	n/a	s = BytesIO()
3092	n/a	g = email.generator.BytesGenerator(s)
3093	n/a	g.flatten(msg, linesep='\r\n')
3094	n/a	self.assertEqual(s.getvalue(), text)
3095	n/a	maxDiff = None
3096	n/a
3097	n/a
3098	n/a	class BaseTestBytesGeneratorIdempotent:
3099	n/a
3100	n/a	maxDiff = None
3101	n/a
3102	n/a	def _msgobj(self, filename):
3103	n/a	with openfile(filename, 'rb') as fp:
3104	n/a	data = fp.read()
3105	n/a	data = self.normalize_linesep_regex.sub(self.blinesep, data)
3106	n/a	msg = email.message_from_bytes(data)
3107	n/a	return msg, data
3108	n/a
3109	n/a	def _idempotent(self, msg, data, unixfrom=False):
3110	n/a	b = BytesIO()
3111	n/a	g = email.generator.BytesGenerator(b, maxheaderlen=0)
3112	n/a	g.flatten(msg, unixfrom=unixfrom, linesep=self.linesep)
3113	n/a	self.assertByteStringsEqual(data, b.getvalue())
3114	n/a
3115	n/a	def assertByteStringsEqual(self, str1, str2):
3116	n/a	# Not using self.blinesep here is intentional. This way the output
3117	n/a	# is more useful when the failure results in mixed line endings.
3118	n/a	self.assertListEqual(str1.split(b'\n'), str2.split(b'\n'))
3119	n/a
3120	n/a
3121	n/a	class TestBytesGeneratorIdempotentNL(BaseTestBytesGeneratorIdempotent,
3122	n/a	TestIdempotent):
3123	n/a	linesep = '\n'
3124	n/a	blinesep = b'\n'
3125	n/a	normalize_linesep_regex = re.compile(br'\r\n')
3126	n/a
3127	n/a
3128	n/a	class TestBytesGeneratorIdempotentCRLF(BaseTestBytesGeneratorIdempotent,
3129	n/a	TestIdempotent):
3130	n/a	linesep = '\r\n'
3131	n/a	blinesep = b'\r\n'
3132	n/a	normalize_linesep_regex = re.compile(br'(?<!\r)\n')
3133	n/a
3134	n/a
3135	n/a	class TestBase64(unittest.TestCase):
3136	n/a	def test_len(self):
3137	n/a	eq = self.assertEqual
3138	n/a	eq(base64mime.header_length('hello'),
3139	n/a	len(base64mime.body_encode(b'hello', eol='')))
3140	n/a	for size in range(15):
3141	n/a	if size == 0 : bsize = 0
3142	n/a	elif size <= 3 : bsize = 4
3143	n/a	elif size <= 6 : bsize = 8
3144	n/a	elif size <= 9 : bsize = 12
3145	n/a	elif size <= 12: bsize = 16
3146	n/a	else : bsize = 20
3147	n/a	eq(base64mime.header_length('x' * size), bsize)
3148	n/a
3149	n/a	def test_decode(self):
3150	n/a	eq = self.assertEqual
3151	n/a	eq(base64mime.decode(''), b'')
3152	n/a	eq(base64mime.decode('aGVsbG8='), b'hello')
3153	n/a
3154	n/a	def test_encode(self):
3155	n/a	eq = self.assertEqual
3156	n/a	eq(base64mime.body_encode(b''), b'')
3157	n/a	eq(base64mime.body_encode(b'hello'), 'aGVsbG8=\n')
3158	n/a	# Test the binary flag
3159	n/a	eq(base64mime.body_encode(b'hello\n'), 'aGVsbG8K\n')
3160	n/a	# Test the maxlinelen arg
3161	n/a	eq(base64mime.body_encode(b'xxxx ' * 20, maxlinelen=40), """\
3162	n/a	eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
3163	n/a	eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
3164	n/a	eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
3165	n/a	eHh4eCB4eHh4IA==
3166	n/a	""")
3167	n/a	# Test the eol argument
3168	n/a	eq(base64mime.body_encode(b'xxxx ' * 20, maxlinelen=40, eol='\r\n'),
3169	n/a	"""\
3170	n/a	eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
3171	n/a	eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
3172	n/a	eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
3173	n/a	eHh4eCB4eHh4IA==\r
3174	n/a	""")
3175	n/a
3176	n/a	def test_header_encode(self):
3177	n/a	eq = self.assertEqual
3178	n/a	he = base64mime.header_encode
3179	n/a	eq(he('hello'), '=?iso-8859-1?b?aGVsbG8=?=')
3180	n/a	eq(he('hello\r\nworld'), '=?iso-8859-1?b?aGVsbG8NCndvcmxk?=')
3181	n/a	eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')
3182	n/a	# Test the charset option
3183	n/a	eq(he('hello', charset='iso-8859-2'), '=?iso-8859-2?b?aGVsbG8=?=')
3184	n/a	eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')
3185	n/a
3186	n/a
3187	n/a
3188	n/a	class TestQuopri(unittest.TestCase):
3189	n/a	def setUp(self):
3190	n/a	# Set of characters (as byte integers) that don't need to be encoded
3191	n/a	# in headers.
3192	n/a	self.hlit = list(chain(
3193	n/a	range(ord('a'), ord('z') + 1),
3194	n/a	range(ord('A'), ord('Z') + 1),
3195	n/a	range(ord('0'), ord('9') + 1),
3196	n/a	(c for c in b'!*+-/')))
3197	n/a	# Set of characters (as byte integers) that do need to be encoded in
3198	n/a	# headers.
3199	n/a	self.hnon = [c for c in range(256) if c not in self.hlit]
3200	n/a	assert len(self.hlit) + len(self.hnon) == 256
3201	n/a	# Set of characters (as byte integers) that don't need to be encoded
3202	n/a	# in bodies.
3203	n/a	self.blit = list(range(ord(' '), ord('~') + 1))
3204	n/a	self.blit.append(ord('\t'))
3205	n/a	self.blit.remove(ord('='))
3206	n/a	# Set of characters (as byte integers) that do need to be encoded in
3207	n/a	# bodies.
3208	n/a	self.bnon = [c for c in range(256) if c not in self.blit]
3209	n/a	assert len(self.blit) + len(self.bnon) == 256
3210	n/a
3211	n/a	def test_quopri_header_check(self):
3212	n/a	for c in self.hlit:
3213	n/a	self.assertFalse(quoprimime.header_check(c),
3214	n/a	'Should not be header quopri encoded: %s' % chr(c))
3215	n/a	for c in self.hnon:
3216	n/a	self.assertTrue(quoprimime.header_check(c),
3217	n/a	'Should be header quopri encoded: %s' % chr(c))
3218	n/a
3219	n/a	def test_quopri_body_check(self):
3220	n/a	for c in self.blit:
3221	n/a	self.assertFalse(quoprimime.body_check(c),
3222	n/a	'Should not be body quopri encoded: %s' % chr(c))
3223	n/a	for c in self.bnon:
3224	n/a	self.assertTrue(quoprimime.body_check(c),
3225	n/a	'Should be body quopri encoded: %s' % chr(c))
3226	n/a
3227	n/a	def test_header_quopri_len(self):
3228	n/a	eq = self.assertEqual
3229	n/a	eq(quoprimime.header_length(b'hello'), 5)
3230	n/a	# RFC 2047 chrome is not included in header_length().
3231	n/a	eq(len(quoprimime.header_encode(b'hello', charset='xxx')),
3232	n/a	quoprimime.header_length(b'hello') +
3233	n/a	# =?xxx?q?...?= means 10 extra characters
3234	n/a	10)
3235	n/a	eq(quoprimime.header_length(b'h@e@l@l@o@'), 20)
3236	n/a	# RFC 2047 chrome is not included in header_length().
3237	n/a	eq(len(quoprimime.header_encode(b'h@e@l@l@o@', charset='xxx')),
3238	n/a	quoprimime.header_length(b'h@e@l@l@o@') +
3239	n/a	# =?xxx?q?...?= means 10 extra characters
3240	n/a	10)
3241	n/a	for c in self.hlit:
3242	n/a	eq(quoprimime.header_length(bytes([c])), 1,
3243	n/a	'expected length 1 for %r' % chr(c))
3244	n/a	for c in self.hnon:
3245	n/a	# Space is special; it's encoded to _
3246	n/a	if c == ord(' '):
3247	n/a	continue
3248	n/a	eq(quoprimime.header_length(bytes([c])), 3,
3249	n/a	'expected length 3 for %r' % chr(c))
3250	n/a	eq(quoprimime.header_length(b' '), 1)
3251	n/a
3252	n/a	def test_body_quopri_len(self):
3253	n/a	eq = self.assertEqual
3254	n/a	for c in self.blit:
3255	n/a	eq(quoprimime.body_length(bytes([c])), 1)
3256	n/a	for c in self.bnon:
3257	n/a	eq(quoprimime.body_length(bytes([c])), 3)
3258	n/a
3259	n/a	def test_quote_unquote_idempotent(self):
3260	n/a	for x in range(256):
3261	n/a	c = chr(x)
3262	n/a	self.assertEqual(quoprimime.unquote(quoprimime.quote(c)), c)
3263	n/a
3264	n/a	def test_header_encode(self):
3265	n/a	eq = self.assertEqual
3266	n/a	he = quoprimime.header_encode
3267	n/a	eq(he(b'hello'), '=?iso-8859-1?q?hello?=')
3268	n/a	eq(he(b'hello', charset='iso-8859-2'), '=?iso-8859-2?q?hello?=')
3269	n/a	eq(he(b'hello\nworld'), '=?iso-8859-1?q?hello=0Aworld?=')
3270	n/a	# Test a non-ASCII character
3271	n/a	eq(he(b'hello\xc7there'), '=?iso-8859-1?q?hello=C7there?=')
3272	n/a
3273	n/a	def test_decode(self):
3274	n/a	eq = self.assertEqual
3275	n/a	eq(quoprimime.decode(''), '')
3276	n/a	eq(quoprimime.decode('hello'), 'hello')
3277	n/a	eq(quoprimime.decode('hello', 'X'), 'hello')
3278	n/a	eq(quoprimime.decode('hello\nworld', 'X'), 'helloXworld')
3279	n/a
3280	n/a	def test_encode(self):
3281	n/a	eq = self.assertEqual
3282	n/a	eq(quoprimime.body_encode(''), '')
3283	n/a	eq(quoprimime.body_encode('hello'), 'hello')
3284	n/a	# Test the binary flag
3285	n/a	eq(quoprimime.body_encode('hello\r\nworld'), 'hello\nworld')
3286	n/a	# Test the maxlinelen arg
3287	n/a	eq(quoprimime.body_encode('xxxx ' * 20, maxlinelen=40), """\
3288	n/a	xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=
3289	n/a	xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=
3290	n/a	x xxxx xxxx xxxx xxxx=20""")
3291	n/a	# Test the eol argument
3292	n/a	eq(quoprimime.body_encode('xxxx ' * 20, maxlinelen=40, eol='\r\n'),
3293	n/a	"""\
3294	n/a	xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=\r
3295	n/a	xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=\r
3296	n/a	x xxxx xxxx xxxx xxxx=20""")
3297	n/a	eq(quoprimime.body_encode("""\
3298	n/a	one line
3299	n/a
3300	n/a	two line"""), """\
3301	n/a	one line
3302	n/a
3303	n/a	two line""")
3304	n/a
3305	n/a
3306	n/a
3307	n/a	# Test the Charset class
3308	n/a	class TestCharset(unittest.TestCase):
3309	n/a	def tearDown(self):
3310	n/a	from email import charset as CharsetModule
3311	n/a	try:
3312	n/a	del CharsetModule.CHARSETS['fake']
3313	n/a	except KeyError:
3314	n/a	pass
3315	n/a
3316	n/a	def test_codec_encodeable(self):
3317	n/a	eq = self.assertEqual
3318	n/a	# Make sure us-ascii = no Unicode conversion
3319	n/a	c = Charset('us-ascii')
3320	n/a	eq(c.header_encode('Hello World!'), 'Hello World!')
3321	n/a	# Test 8-bit idempotency with us-ascii
3322	n/a	s = '\xa4\xa2\xa4\xa4\xa4\xa6\xa4\xa8\xa4\xaa'
3323	n/a	self.assertRaises(UnicodeError, c.header_encode, s)
3324	n/a	c = Charset('utf-8')
3325	n/a	eq(c.header_encode(s), '=?utf-8?b?wqTCosKkwqTCpMKmwqTCqMKkwqo=?=')
3326	n/a
3327	n/a	def test_body_encode(self):
3328	n/a	eq = self.assertEqual
3329	n/a	# Try a charset with QP body encoding
3330	n/a	c = Charset('iso-8859-1')
3331	n/a	eq('hello w=F6rld', c.body_encode('hello w\xf6rld'))
3332	n/a	# Try a charset with Base64 body encoding
3333	n/a	c = Charset('utf-8')
3334	n/a	eq('aGVsbG8gd29ybGQ=\n', c.body_encode(b'hello world'))
3335	n/a	# Try a charset with None body encoding
3336	n/a	c = Charset('us-ascii')
3337	n/a	eq('hello world', c.body_encode('hello world'))
3338	n/a	# Try the convert argument, where input codec != output codec
3339	n/a	c = Charset('euc-jp')
3340	n/a	# With apologies to Tokio Kikuchi ;)
3341	n/a	# XXX FIXME
3342	n/a	## try:
3343	n/a	## eq('\x1b$B5FCO;~IW\x1b(B',
3344	n/a	## c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7'))
3345	n/a	## eq('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7',
3346	n/a	## c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7', False))
3347	n/a	## except LookupError:
3348	n/a	## # We probably don't have the Japanese codecs installed
3349	n/a	## pass
3350	n/a	# Testing SF bug #625509, which we have to fake, since there are no
3351	n/a	# built-in encodings where the header encoding is QP but the body
3352	n/a	# encoding is not.
3353	n/a	from email import charset as CharsetModule
3354	n/a	CharsetModule.add_charset('fake', CharsetModule.QP, None)
3355	n/a	c = Charset('fake')
3356	n/a	eq('hello w\xf6rld', c.body_encode('hello w\xf6rld'))
3357	n/a
3358	n/a	def test_unicode_charset_name(self):
3359	n/a	charset = Charset('us-ascii')
3360	n/a	self.assertEqual(str(charset), 'us-ascii')
3361	n/a	self.assertRaises(errors.CharsetError, Charset, 'asc\xffii')
3362	n/a
3363	n/a
3364	n/a
3365	n/a	# Test multilingual MIME headers.
3366	n/a	class TestHeader(TestEmailBase):
3367	n/a	def test_simple(self):
3368	n/a	eq = self.ndiffAssertEqual
3369	n/a	h = Header('Hello World!')
3370	n/a	eq(h.encode(), 'Hello World!')
3371	n/a	h.append(' Goodbye World!')
3372	n/a	eq(h.encode(), 'Hello World! Goodbye World!')
3373	n/a
3374	n/a	def test_simple_surprise(self):
3375	n/a	eq = self.ndiffAssertEqual
3376	n/a	h = Header('Hello World!')
3377	n/a	eq(h.encode(), 'Hello World!')
3378	n/a	h.append('Goodbye World!')
3379	n/a	eq(h.encode(), 'Hello World! Goodbye World!')
3380	n/a
3381	n/a	def test_header_needs_no_decoding(self):
3382	n/a	h = 'no decoding needed'
3383	n/a	self.assertEqual(decode_header(h), [(h, None)])
3384	n/a
3385	n/a	def test_long(self):
3386	n/a	h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.",
3387	n/a	maxlinelen=76)
3388	n/a	for l in h.encode(splitchars=' ').split('\n '):
3389	n/a	self.assertTrue(len(l) <= 76)
3390	n/a
3391	n/a	def test_multilingual(self):
3392	n/a	eq = self.ndiffAssertEqual
3393	n/a	g = Charset("iso-8859-1")
3394	n/a	cz = Charset("iso-8859-2")
3395	n/a	utf8 = Charset("utf-8")
3396	n/a	g_head = (b'Die Mieter treten hier ein werden mit einem '
3397	n/a	b'Foerderband komfortabel den Korridor entlang, '
3398	n/a	b'an s\xfcdl\xfcndischen Wandgem\xe4lden vorbei, '
3399	n/a	b'gegen die rotierenden Klingen bef\xf6rdert. ')
3400	n/a	cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '
3401	n/a	b'd\xf9vtipu.. ')
3402	n/a	utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
3403	n/a	'\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
3404	n/a	'\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
3405	n/a	'\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
3406	n/a	'\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '
3407	n/a	'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '
3408	n/a	'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'
3409	n/a	'\u3044\u307e\u3059\u3002')
3410	n/a	h = Header(g_head, g)
3411	n/a	h.append(cz_head, cz)
3412	n/a	h.append(utf8_head, utf8)
3413	n/a	enc = h.encode(maxlinelen=76)
3414	n/a	eq(enc, """\
3415	n/a	=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderband_kom?=
3416	n/a	=?iso-8859-1?q?fortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen_Wand?=
3417	n/a	=?iso-8859-1?q?gem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef=F6r?=
3418	n/a	=?iso-8859-1?q?dert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hroutily?=
3419	n/a	=?iso-8859-2?q?_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=
3420	n/a	=?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC?=
3421	n/a	=?utf-8?b?5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn?=
3422	n/a	=?utf-8?b?44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFz?=
3423	n/a	=?utf-8?b?IE51bnN0dWNrIGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWloZXJodW5k?=
3424	n/a	=?utf-8?b?IGRhcyBPZGVyIGRpZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI3jgajoqIA=?=
3425	n/a	=?utf-8?b?44Gj44Gm44GE44G+44GZ44CC?=""")
3426	n/a	decoded = decode_header(enc)
3427	n/a	eq(len(decoded), 3)
3428	n/a	eq(decoded[0], (g_head, 'iso-8859-1'))
3429	n/a	eq(decoded[1], (cz_head, 'iso-8859-2'))
3430	n/a	eq(decoded[2], (utf8_head.encode('utf-8'), 'utf-8'))
3431	n/a	ustr = str(h)
3432	n/a	eq(ustr,
3433	n/a	(b'Die Mieter treten hier ein werden mit einem Foerderband '
3434	n/a	b'komfortabel den Korridor entlang, an s\xc3\xbcdl\xc3\xbcndischen '
3435	n/a	b'Wandgem\xc3\xa4lden vorbei, gegen die rotierenden Klingen '
3436	n/a	b'bef\xc3\xb6rdert. Finan\xc4\x8dni metropole se hroutily pod '
3437	n/a	b'tlakem jejich d\xc5\xafvtipu.. \xe6\xad\xa3\xe7\xa2\xba\xe3\x81'
3438	n/a	b'\xab\xe8\xa8\x80\xe3\x81\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3'
3439	n/a	b'\xe3\x81\xaf\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3'
3440	n/a	b'\x81\xbe\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'
3441	n/a	b'\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8\xaa\x9e'
3442	n/a	b'\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81\xe3\x81\x82\xe3'
3443	n/a	b'\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81\x9f\xe3\x82\x89\xe3\x82'
3444	n/a	b'\x81\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\xe5\xae\x9f\xe9\x9a\x9b'
3445	n/a	b'\xe3\x81\xab\xe3\x81\xaf\xe3\x80\x8cWenn ist das Nunstuck git '
3446	n/a	b'und Slotermeyer? Ja! Beiherhund das Oder die Flipperwaldt '
3447	n/a	b'gersput.\xe3\x80\x8d\xe3\x81\xa8\xe8\xa8\x80\xe3\x81\xa3\xe3\x81'
3448	n/a	b'\xa6\xe3\x81\x84\xe3\x81\xbe\xe3\x81\x99\xe3\x80\x82'
3449	n/a	).decode('utf-8'))
3450	n/a	# Test make_header()
3451	n/a	newh = make_header(decode_header(enc))
3452	n/a	eq(newh, h)
3453	n/a
3454	n/a	def test_empty_header_encode(self):
3455	n/a	h = Header()
3456	n/a	self.assertEqual(h.encode(), '')
3457	n/a
3458	n/a	def test_header_ctor_default_args(self):
3459	n/a	eq = self.ndiffAssertEqual
3460	n/a	h = Header()
3461	n/a	eq(h, '')
3462	n/a	h.append('foo', Charset('iso-8859-1'))
3463	n/a	eq(h, 'foo')
3464	n/a
3465	n/a	def test_explicit_maxlinelen(self):
3466	n/a	eq = self.ndiffAssertEqual
3467	n/a	hstr = ('A very long line that must get split to something other '
3468	n/a	'than at the 76th character boundary to test the non-default '
3469	n/a	'behavior')
3470	n/a	h = Header(hstr)
3471	n/a	eq(h.encode(), '''\
3472	n/a	A very long line that must get split to something other than at the 76th
3473	n/a	character boundary to test the non-default behavior''')
3474	n/a	eq(str(h), hstr)
3475	n/a	h = Header(hstr, header_name='Subject')
3476	n/a	eq(h.encode(), '''\
3477	n/a	A very long line that must get split to something other than at the
3478	n/a	76th character boundary to test the non-default behavior''')
3479	n/a	eq(str(h), hstr)
3480	n/a	h = Header(hstr, maxlinelen=1024, header_name='Subject')
3481	n/a	eq(h.encode(), hstr)
3482	n/a	eq(str(h), hstr)
3483	n/a
3484	n/a	def test_quopri_splittable(self):
3485	n/a	eq = self.ndiffAssertEqual
3486	n/a	h = Header(charset='iso-8859-1', maxlinelen=20)
3487	n/a	x = 'xxxx ' * 20
3488	n/a	h.append(x)
3489	n/a	s = h.encode()
3490	n/a	eq(s, """\
3491	n/a	=?iso-8859-1?q?xxx?=
3492	n/a	=?iso-8859-1?q?x_?=
3493	n/a	=?iso-8859-1?q?xx?=
3494	n/a	=?iso-8859-1?q?xx?=
3495	n/a	=?iso-8859-1?q?_x?=
3496	n/a	=?iso-8859-1?q?xx?=
3497	n/a	=?iso-8859-1?q?x_?=
3498	n/a	=?iso-8859-1?q?xx?=
3499	n/a	=?iso-8859-1?q?xx?=
3500	n/a	=?iso-8859-1?q?_x?=
3501	n/a	=?iso-8859-1?q?xx?=
3502	n/a	=?iso-8859-1?q?x_?=
3503	n/a	=?iso-8859-1?q?xx?=
3504	n/a	=?iso-8859-1?q?xx?=
3505	n/a	=?iso-8859-1?q?_x?=
3506	n/a	=?iso-8859-1?q?xx?=
3507	n/a	=?iso-8859-1?q?x_?=
3508	n/a	=?iso-8859-1?q?xx?=
3509	n/a	=?iso-8859-1?q?xx?=
3510	n/a	=?iso-8859-1?q?_x?=
3511	n/a	=?iso-8859-1?q?xx?=
3512	n/a	=?iso-8859-1?q?x_?=
3513	n/a	=?iso-8859-1?q?xx?=
3514	n/a	=?iso-8859-1?q?xx?=
3515	n/a	=?iso-8859-1?q?_x?=
3516	n/a	=?iso-8859-1?q?xx?=
3517	n/a	=?iso-8859-1?q?x_?=
3518	n/a	=?iso-8859-1?q?xx?=
3519	n/a	=?iso-8859-1?q?xx?=
3520	n/a	=?iso-8859-1?q?_x?=
3521	n/a	=?iso-8859-1?q?xx?=
3522	n/a	=?iso-8859-1?q?x_?=
3523	n/a	=?iso-8859-1?q?xx?=
3524	n/a	=?iso-8859-1?q?xx?=
3525	n/a	=?iso-8859-1?q?_x?=
3526	n/a	=?iso-8859-1?q?xx?=
3527	n/a	=?iso-8859-1?q?x_?=
3528	n/a	=?iso-8859-1?q?xx?=
3529	n/a	=?iso-8859-1?q?xx?=
3530	n/a	=?iso-8859-1?q?_x?=
3531	n/a	=?iso-8859-1?q?xx?=
3532	n/a	=?iso-8859-1?q?x_?=
3533	n/a	=?iso-8859-1?q?xx?=
3534	n/a	=?iso-8859-1?q?xx?=
3535	n/a	=?iso-8859-1?q?_x?=
3536	n/a	=?iso-8859-1?q?xx?=
3537	n/a	=?iso-8859-1?q?x_?=
3538	n/a	=?iso-8859-1?q?xx?=
3539	n/a	=?iso-8859-1?q?xx?=
3540	n/a	=?iso-8859-1?q?_?=""")
3541	n/a	eq(x, str(make_header(decode_header(s))))
3542	n/a	h = Header(charset='iso-8859-1', maxlinelen=40)
3543	n/a	h.append('xxxx ' * 20)
3544	n/a	s = h.encode()
3545	n/a	eq(s, """\
3546	n/a	=?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xxx?=
3547	n/a	=?iso-8859-1?q?x_xxxx_xxxx_xxxx_xxxx_?=
3548	n/a	=?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xx?=
3549	n/a	=?iso-8859-1?q?xx_xxxx_xxxx_xxxx_xxxx?=
3550	n/a	=?iso-8859-1?q?_xxxx_xxxx_?=""")
3551	n/a	eq(x, str(make_header(decode_header(s))))
3552	n/a
3553	n/a	def test_base64_splittable(self):
3554	n/a	eq = self.ndiffAssertEqual
3555	n/a	h = Header(charset='koi8-r', maxlinelen=20)
3556	n/a	x = 'xxxx ' * 20
3557	n/a	h.append(x)
3558	n/a	s = h.encode()
3559	n/a	eq(s, """\
3560	n/a	=?koi8-r?b?eHh4?=
3561	n/a	=?koi8-r?b?eCB4?=
3562	n/a	=?koi8-r?b?eHh4?=
3563	n/a	=?koi8-r?b?IHh4?=
3564	n/a	=?koi8-r?b?eHgg?=
3565	n/a	=?koi8-r?b?eHh4?=
3566	n/a	=?koi8-r?b?eCB4?=
3567	n/a	=?koi8-r?b?eHh4?=
3568	n/a	=?koi8-r?b?IHh4?=
3569	n/a	=?koi8-r?b?eHgg?=
3570	n/a	=?koi8-r?b?eHh4?=
3571	n/a	=?koi8-r?b?eCB4?=
3572	n/a	=?koi8-r?b?eHh4?=
3573	n/a	=?koi8-r?b?IHh4?=
3574	n/a	=?koi8-r?b?eHgg?=
3575	n/a	=?koi8-r?b?eHh4?=
3576	n/a	=?koi8-r?b?eCB4?=
3577	n/a	=?koi8-r?b?eHh4?=
3578	n/a	=?koi8-r?b?IHh4?=
3579	n/a	=?koi8-r?b?eHgg?=
3580	n/a	=?koi8-r?b?eHh4?=
3581	n/a	=?koi8-r?b?eCB4?=
3582	n/a	=?koi8-r?b?eHh4?=
3583	n/a	=?koi8-r?b?IHh4?=
3584	n/a	=?koi8-r?b?eHgg?=
3585	n/a	=?koi8-r?b?eHh4?=
3586	n/a	=?koi8-r?b?eCB4?=
3587	n/a	=?koi8-r?b?eHh4?=
3588	n/a	=?koi8-r?b?IHh4?=
3589	n/a	=?koi8-r?b?eHgg?=
3590	n/a	=?koi8-r?b?eHh4?=
3591	n/a	=?koi8-r?b?eCB4?=
3592	n/a	=?koi8-r?b?eHh4?=
3593	n/a	=?koi8-r?b?IA==?=""")
3594	n/a	eq(x, str(make_header(decode_header(s))))
3595	n/a	h = Header(charset='koi8-r', maxlinelen=40)
3596	n/a	h.append(x)
3597	n/a	s = h.encode()
3598	n/a	eq(s, """\
3599	n/a	=?koi8-r?b?eHh4eCB4eHh4IHh4eHggeHh4?=
3600	n/a	=?koi8-r?b?eCB4eHh4IHh4eHggeHh4eCB4?=
3601	n/a	=?koi8-r?b?eHh4IHh4eHggeHh4eCB4eHh4?=
3602	n/a	=?koi8-r?b?IHh4eHggeHh4eCB4eHh4IHh4?=
3603	n/a	=?koi8-r?b?eHggeHh4eCB4eHh4IHh4eHgg?=
3604	n/a	=?koi8-r?b?eHh4eCB4eHh4IA==?=""")
3605	n/a	eq(x, str(make_header(decode_header(s))))
3606	n/a
3607	n/a	def test_us_ascii_header(self):
3608	n/a	eq = self.assertEqual
3609	n/a	s = 'hello'
3610	n/a	x = decode_header(s)
3611	n/a	eq(x, [('hello', None)])
3612	n/a	h = make_header(x)
3613	n/a	eq(s, h.encode())
3614	n/a
3615	n/a	def test_string_charset(self):
3616	n/a	eq = self.assertEqual
3617	n/a	h = Header()
3618	n/a	h.append('hello', 'iso-8859-1')
3619	n/a	eq(h, 'hello')
3620	n/a
3621	n/a	## def test_unicode_error(self):
3622	n/a	## raises = self.assertRaises
3623	n/a	## raises(UnicodeError, Header, u'[P\xf6stal]', 'us-ascii')
3624	n/a	## raises(UnicodeError, Header, '[P\xf6stal]', 'us-ascii')
3625	n/a	## h = Header()
3626	n/a	## raises(UnicodeError, h.append, u'[P\xf6stal]', 'us-ascii')
3627	n/a	## raises(UnicodeError, h.append, '[P\xf6stal]', 'us-ascii')
3628	n/a	## raises(UnicodeError, Header, u'\u83ca\u5730\u6642\u592b', 'iso-8859-1')
3629	n/a
3630	n/a	def test_utf8_shortest(self):
3631	n/a	eq = self.assertEqual
3632	n/a	h = Header('p\xf6stal', 'utf-8')
3633	n/a	eq(h.encode(), '=?utf-8?q?p=C3=B6stal?=')
3634	n/a	h = Header('\u83ca\u5730\u6642\u592b', 'utf-8')
3635	n/a	eq(h.encode(), '=?utf-8?b?6I+K5Zyw5pmC5aSr?=')
3636	n/a
3637	n/a	def test_bad_8bit_header(self):
3638	n/a	raises = self.assertRaises
3639	n/a	eq = self.assertEqual
3640	n/a	x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
3641	n/a	raises(UnicodeError, Header, x)
3642	n/a	h = Header()
3643	n/a	raises(UnicodeError, h.append, x)
3644	n/a	e = x.decode('utf-8', 'replace')
3645	n/a	eq(str(Header(x, errors='replace')), e)
3646	n/a	h.append(x, errors='replace')
3647	n/a	eq(str(h), e)
3648	n/a
3649	n/a	def test_encoded_adjacent_nonencoded(self):
3650	n/a	eq = self.assertEqual
3651	n/a	h = Header()
3652	n/a	h.append('hello', 'iso-8859-1')
3653	n/a	h.append('world')
3654	n/a	s = h.encode()
3655	n/a	eq(s, '=?iso-8859-1?q?hello?= world')
3656	n/a	h = make_header(decode_header(s))
3657	n/a	eq(h.encode(), s)
3658	n/a
3659	n/a	def test_whitespace_eater(self):
3660	n/a	eq = self.assertEqual
3661	n/a	s = 'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztk=?= =?koi8-r?q?=CA?= zz.'
3662	n/a	parts = decode_header(s)
3663	n/a	eq(parts, [(b'Subject:', None), (b'\xf0\xd2\xcf\xd7\xc5\xd2\xcb\xc1 \xce\xc1 \xc6\xc9\xce\xc1\xcc\xd8\xce\xd9\xca', 'koi8-r'), (b'zz.', None)])
3664	n/a	hdr = make_header(parts)
3665	n/a	eq(hdr.encode(),
3666	n/a	'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztnK?= zz.')
3667	n/a
3668	n/a	def test_broken_base64_header(self):
3669	n/a	raises = self.assertRaises
3670	n/a	s = 'Subject: =?EUC-KR?B?CSixpLDtKSC/7Liuvsax4iC6uLmwMcijIKHaILzSwd/H0SC8+LCjwLsgv7W/+Mj3I ?='
3671	n/a	raises(errors.HeaderParseError, decode_header, s)
3672	n/a
3673	n/a	def test_shift_jis_charset(self):
3674	n/a	h = Header('æ–‡', charset='shift_jis')
3675	n/a	self.assertEqual(h.encode(), '=?iso-2022-jp?b?GyRCSjgbKEI=?=')
3676	n/a
3677	n/a
3678	n/a
3679	n/a	# Test RFC 2231 header parameters (en/de)coding
3680	n/a	class TestRFC2231(TestEmailBase):
3681	n/a	def test_get_param(self):
3682	n/a	eq = self.assertEqual
3683	n/a	msg = self._msgobj('msg_29.txt')
3684	n/a	eq(msg.get_param('title'),
3685	n/a	('us-ascii', 'en', 'This is even more *fun* isn\'t it!'))
3686	n/a	eq(msg.get_param('title', unquote=False),
3687	n/a	('us-ascii', 'en', '"This is even more *fun* isn\'t it!"'))
3688	n/a
3689	n/a	def test_set_param(self):
3690	n/a	eq = self.ndiffAssertEqual
3691	n/a	msg = Message()
3692	n/a	msg.set_param('title', 'This is even more *fun* isn\'t it!',
3693	n/a	charset='us-ascii')
3694	n/a	eq(msg.get_param('title'),
3695	n/a	('us-ascii', '', 'This is even more *fun* isn\'t it!'))
3696	n/a	msg.set_param('title', 'This is even more *fun* isn\'t it!',
3697	n/a	charset='us-ascii', language='en')
3698	n/a	eq(msg.get_param('title'),
3699	n/a	('us-ascii', 'en', 'This is even more *fun* isn\'t it!'))
3700	n/a	msg = self._msgobj('msg_01.txt')
3701	n/a	msg.set_param('title', 'This is even more *fun* isn\'t it!',
3702	n/a	charset='us-ascii', language='en')
3703	n/a	eq(msg.as_string(maxheaderlen=78), """\
3704	n/a	Return-Path: <bbb@zzz.org>
3705	n/a	Delivered-To: bbb@zzz.org
3706	n/a	Received: by mail.zzz.org (Postfix, from userid 889)
3707	n/a	\tid 27CEAD38CC; Fri, 4 May 2001 14:05:44 -0400 (EDT)
3708	n/a	MIME-Version: 1.0
3709	n/a	Content-Transfer-Encoding: 7bit
3710	n/a	Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
3711	n/a	From: bbb@ddd.com (John X. Doe)
3712	n/a	To: bbb@zzz.org
3713	n/a	Subject: This is a test message
3714	n/a	Date: Fri, 4 May 2001 14:05:44 -0400
3715	n/a	Content-Type: text/plain; charset=us-ascii;
3716	n/a	title*=us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21
3717	n/a
3718	n/a
3719	n/a	Hi,
3720	n/a
3721	n/a	Do you like this message?
3722	n/a
3723	n/a	-Me
3724	n/a	""")
3725	n/a
3726	n/a	def test_del_param(self):
3727	n/a	eq = self.ndiffAssertEqual
3728	n/a	msg = self._msgobj('msg_01.txt')
3729	n/a	msg.set_param('foo', 'bar', charset='us-ascii', language='en')
3730	n/a	msg.set_param('title', 'This is even more *fun* isn\'t it!',
3731	n/a	charset='us-ascii', language='en')
3732	n/a	msg.del_param('foo', header='Content-Type')
3733	n/a	eq(msg.as_string(maxheaderlen=78), """\
3734	n/a	Return-Path: <bbb@zzz.org>
3735	n/a	Delivered-To: bbb@zzz.org
3736	n/a	Received: by mail.zzz.org (Postfix, from userid 889)
3737	n/a	\tid 27CEAD38CC; Fri, 4 May 2001 14:05:44 -0400 (EDT)
3738	n/a	MIME-Version: 1.0
3739	n/a	Content-Transfer-Encoding: 7bit
3740	n/a	Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
3741	n/a	From: bbb@ddd.com (John X. Doe)
3742	n/a	To: bbb@zzz.org
3743	n/a	Subject: This is a test message
3744	n/a	Date: Fri, 4 May 2001 14:05:44 -0400
3745	n/a	Content-Type: text/plain; charset="us-ascii";
3746	n/a	title*=us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21
3747	n/a
3748	n/a
3749	n/a	Hi,
3750	n/a
3751	n/a	Do you like this message?
3752	n/a
3753	n/a	-Me
3754	n/a	""")
3755	n/a
3756	n/a	def test_rfc2231_get_content_charset(self):
3757	n/a	eq = self.assertEqual
3758	n/a	msg = self._msgobj('msg_32.txt')
3759	n/a	eq(msg.get_content_charset(), 'us-ascii')
3760	n/a
3761	n/a	def test_rfc2231_parse_rfc_quoting(self):
3762	n/a	m = textwrap.dedent('''\
3763	n/a	Content-Disposition: inline;
3764	n/a	\tfilename0=''This%20is%20even%20more%20;
3765	n/a	\tfilename1=%2A%2A%2Afun%2A%2A%2A%20;
3766	n/a	\tfilename*2="is it not.pdf"
3767	n/a
3768	n/a	''')
3769	n/a	msg = email.message_from_string(m)
3770	n/a	self.assertEqual(msg.get_filename(),
3771	n/a	'This is even more *fun* is it not.pdf')
3772	n/a	self.assertEqual(m, msg.as_string())
3773	n/a
3774	n/a	def test_rfc2231_parse_extra_quoting(self):
3775	n/a	m = textwrap.dedent('''\
3776	n/a	Content-Disposition: inline;
3777	n/a	\tfilename0="''This%20is%20even%20more%20";
3778	n/a	\tfilename1="%2A%2A%2Afun%2A%2A%2A%20";
3779	n/a	\tfilename*2="is it not.pdf"
3780	n/a
3781	n/a	''')
3782	n/a	msg = email.message_from_string(m)
3783	n/a	self.assertEqual(msg.get_filename(),
3784	n/a	'This is even more *fun* is it not.pdf')
3785	n/a	self.assertEqual(m, msg.as_string())
3786	n/a
3787	n/a	def test_rfc2231_no_language_or_charset(self):
3788	n/a	m = '''\
3789	n/a	Content-Transfer-Encoding: 8bit
3790	n/a	Content-Disposition: inline; filename="file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm"
3791	n/a	Content-Type: text/html; NAME0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEM; NAME1=P_nsmail.htm
3792	n/a
3793	n/a	'''
3794	n/a	msg = email.message_from_string(m)
3795	n/a	param = msg.get_param('NAME')
3796	n/a	self.assertFalse(isinstance(param, tuple))
3797	n/a	self.assertEqual(
3798	n/a	param,
3799	n/a	'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')
3800	n/a
3801	n/a	def test_rfc2231_no_language_or_charset_in_filename(self):
3802	n/a	m = '''\
3803	n/a	Content-Disposition: inline;
3804	n/a	\tfilename0="''This%20is%20even%20more%20";
3805	n/a	\tfilename1="%2A%2A%2Afun%2A%2A%2A%20";
3806	n/a	\tfilename*2="is it not.pdf"
3807	n/a
3808	n/a	'''
3809	n/a	msg = email.message_from_string(m)
3810	n/a	self.assertEqual(msg.get_filename(),
3811	n/a	'This is even more *fun* is it not.pdf')
3812	n/a
3813	n/a	def test_rfc2231_no_language_or_charset_in_filename_encoded(self):
3814	n/a	m = '''\
3815	n/a	Content-Disposition: inline;
3816	n/a	\tfilename0="''This%20is%20even%20more%20";
3817	n/a	\tfilename1="%2A%2A%2Afun%2A%2A%2A%20";
3818	n/a	\tfilename*2="is it not.pdf"
3819	n/a
3820	n/a	'''
3821	n/a	msg = email.message_from_string(m)
3822	n/a	self.assertEqual(msg.get_filename(),
3823	n/a	'This is even more *fun* is it not.pdf')
3824	n/a
3825	n/a	def test_rfc2231_partly_encoded(self):
3826	n/a	m = '''\
3827	n/a	Content-Disposition: inline;
3828	n/a	\tfilename*0="''This%20is%20even%20more%20";
3829	n/a	\tfilename1="%2A%2A%2Afun%2A%2A%2A%20";
3830	n/a	\tfilename*2="is it not.pdf"
3831	n/a
3832	n/a	'''
3833	n/a	msg = email.message_from_string(m)
3834	n/a	self.assertEqual(
3835	n/a	msg.get_filename(),
3836	n/a	'This%20is%20even%20more%20*fun* is it not.pdf')
3837	n/a
3838	n/a	def test_rfc2231_partly_nonencoded(self):
3839	n/a	m = '''\
3840	n/a	Content-Disposition: inline;
3841	n/a	\tfilename*0="This%20is%20even%20more%20";
3842	n/a	\tfilename*1="%2A%2A%2Afun%2A%2A%2A%20";
3843	n/a	\tfilename*2="is it not.pdf"
3844	n/a
3845	n/a	'''
3846	n/a	msg = email.message_from_string(m)
3847	n/a	self.assertEqual(
3848	n/a	msg.get_filename(),
3849	n/a	'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20is it not.pdf')
3850	n/a
3851	n/a	def test_rfc2231_no_language_or_charset_in_boundary(self):
3852	n/a	m = '''\
3853	n/a	Content-Type: multipart/alternative;
3854	n/a	\tboundary0="''This%20is%20even%20more%20";
3855	n/a	\tboundary1="%2A%2A%2Afun%2A%2A%2A%20";
3856	n/a	\tboundary*2="is it not.pdf"
3857	n/a
3858	n/a	'''
3859	n/a	msg = email.message_from_string(m)
3860	n/a	self.assertEqual(msg.get_boundary(),
3861	n/a	'This is even more *fun* is it not.pdf')
3862	n/a
3863	n/a	def test_rfc2231_no_language_or_charset_in_charset(self):
3864	n/a	# This is a nonsensical charset value, but tests the code anyway
3865	n/a	m = '''\
3866	n/a	Content-Type: text/plain;
3867	n/a	\tcharset0="This%20is%20even%20more%20";
3868	n/a	\tcharset1="%2A%2A%2Afun%2A%2A%2A%20";
3869	n/a	\tcharset*2="is it not.pdf"
3870	n/a
3871	n/a	'''
3872	n/a	msg = email.message_from_string(m)
3873	n/a	self.assertEqual(msg.get_content_charset(),
3874	n/a	'this is even more *fun* is it not.pdf')
3875	n/a
3876	n/a	def test_rfc2231_bad_encoding_in_filename(self):
3877	n/a	m = '''\
3878	n/a	Content-Disposition: inline;
3879	n/a	\tfilename0="bogus'xx'This%20is%20even%20more%20";
3880	n/a	\tfilename1="%2A%2A%2Afun%2A%2A%2A%20";
3881	n/a	\tfilename*2="is it not.pdf"
3882	n/a
3883	n/a	'''
3884	n/a	msg = email.message_from_string(m)
3885	n/a	self.assertEqual(msg.get_filename(),
3886	n/a	'This is even more *fun* is it not.pdf')
3887	n/a
3888	n/a	def test_rfc2231_bad_encoding_in_charset(self):
3889	n/a	m = """\
3890	n/a	Content-Type: text/plain; charset*=bogus''utf-8%E2%80%9D
3891	n/a
3892	n/a	"""
3893	n/a	msg = email.message_from_string(m)
3894	n/a	# This should return None because non-ascii characters in the charset
3895	n/a	# are not allowed.
3896	n/a	self.assertEqual(msg.get_content_charset(), None)
3897	n/a
3898	n/a	def test_rfc2231_bad_character_in_charset(self):
3899	n/a	m = """\
3900	n/a	Content-Type: text/plain; charset*=ascii''utf-8%E2%80%9D
3901	n/a
3902	n/a	"""
3903	n/a	msg = email.message_from_string(m)
3904	n/a	# This should return None because non-ascii characters in the charset
3905	n/a	# are not allowed.
3906	n/a	self.assertEqual(msg.get_content_charset(), None)
3907	n/a
3908	n/a	def test_rfc2231_bad_character_in_filename(self):
3909	n/a	m = '''\
3910	n/a	Content-Disposition: inline;
3911	n/a	\tfilename0="ascii'xx'This%20is%20even%20more%20";
3912	n/a	\tfilename1="%2A%2A%2Afun%2A%2A%2A%20";
3913	n/a	\tfilename2="is it not.pdf%E2"
3914	n/a
3915	n/a	'''
3916	n/a	msg = email.message_from_string(m)
3917	n/a	self.assertEqual(msg.get_filename(),
3918	n/a	'This is even more *fun* is it not.pdf\ufffd')
3919	n/a
3920	n/a	def test_rfc2231_unknown_encoding(self):
3921	n/a	m = """\
3922	n/a	Content-Transfer-Encoding: 8bit
3923	n/a	Content-Disposition: inline; filename*=X-UNKNOWN''myfile.txt
3924	n/a
3925	n/a	"""
3926	n/a	msg = email.message_from_string(m)
3927	n/a	self.assertEqual(msg.get_filename(), 'myfile.txt')
3928	n/a
3929	n/a	def test_rfc2231_single_tick_in_filename_extended(self):
3930	n/a	eq = self.assertEqual
3931	n/a	m = """\
3932	n/a	Content-Type: application/x-foo;
3933	n/a	\tname0=\"Frank's\"; name1=\" Document\"
3934	n/a
3935	n/a	"""
3936	n/a	msg = email.message_from_string(m)
3937	n/a	charset, language, s = msg.get_param('name')
3938	n/a	eq(charset, None)
3939	n/a	eq(language, None)
3940	n/a	eq(s, "Frank's Document")
3941	n/a
3942	n/a	def test_rfc2231_single_tick_in_filename(self):
3943	n/a	m = """\
3944	n/a	Content-Type: application/x-foo; name0=\"Frank's\"; name1=\" Document\"
3945	n/a
3946	n/a	"""
3947	n/a	msg = email.message_from_string(m)
3948	n/a	param = msg.get_param('name')
3949	n/a	self.assertFalse(isinstance(param, tuple))
3950	n/a	self.assertEqual(param, "Frank's Document")
3951	n/a
3952	n/a	def test_rfc2231_tick_attack_extended(self):
3953	n/a	eq = self.assertEqual
3954	n/a	m = """\
3955	n/a	Content-Type: application/x-foo;
3956	n/a	\tname0=\"us-ascii'en-us'Frank's\"; name1=\" Document\"
3957	n/a
3958	n/a	"""
3959	n/a	msg = email.message_from_string(m)
3960	n/a	charset, language, s = msg.get_param('name')
3961	n/a	eq(charset, 'us-ascii')
3962	n/a	eq(language, 'en-us')
3963	n/a	eq(s, "Frank's Document")
3964	n/a
3965	n/a	def test_rfc2231_tick_attack(self):
3966	n/a	m = """\
3967	n/a	Content-Type: application/x-foo;
3968	n/a	\tname0=\"us-ascii'en-us'Frank's\"; name1=\" Document\"
3969	n/a
3970	n/a	"""
3971	n/a	msg = email.message_from_string(m)
3972	n/a	param = msg.get_param('name')
3973	n/a	self.assertFalse(isinstance(param, tuple))
3974	n/a	self.assertEqual(param, "us-ascii'en-us'Frank's Document")
3975	n/a
3976	n/a	def test_rfc2231_no_extended_values(self):
3977	n/a	eq = self.assertEqual
3978	n/a	m = """\
3979	n/a	Content-Type: application/x-foo; name=\"Frank's Document\"
3980	n/a
3981	n/a	"""
3982	n/a	msg = email.message_from_string(m)
3983	n/a	eq(msg.get_param('name'), "Frank's Document")
3984	n/a
3985	n/a	def test_rfc2231_encoded_then_unencoded_segments(self):
3986	n/a	eq = self.assertEqual
3987	n/a	m = """\
3988	n/a	Content-Type: application/x-foo;
3989	n/a	\tname0=\"us-ascii'en-us'My\";
3990	n/a	\tname*1=\" Document\";
3991	n/a	\tname2=\" For You\"
3992	n/a
3993	n/a	"""
3994	n/a	msg = email.message_from_string(m)
3995	n/a	charset, language, s = msg.get_param('name')
3996	n/a	eq(charset, 'us-ascii')
3997	n/a	eq(language, 'en-us')
3998	n/a	eq(s, 'My Document For You')
3999	n/a
4000	n/a	def test_rfc2231_unencoded_then_encoded_segments(self):
4001	n/a	eq = self.assertEqual
4002	n/a	m = """\
4003	n/a	Content-Type: application/x-foo;
4004	n/a	\tname*0=\"us-ascii'en-us'My\";
4005	n/a	\tname1=\" Document\";
4006	n/a	\tname2=\" For You\"
4007	n/a
4008	n/a	"""
4009	n/a	msg = email.message_from_string(m)
4010	n/a	charset, language, s = msg.get_param('name')
4011	n/a	eq(charset, 'us-ascii')
4012	n/a	eq(language, 'en-us')
4013	n/a	eq(s, 'My Document For You')
4014	n/a
4015	n/a
4016	n/a
4017	n/a	# Tests to ensure that signed parts of an email are completely preserved, as
4018	n/a	# required by RFC1847 section 2.1. Note that these are incomplete, because the
4019	n/a	# email package does not currently always preserve the body. See issue 1670765.
4020	n/a	class TestSigned(TestEmailBase):
4021	n/a
4022	n/a	def _msg_and_obj(self, filename):
4023	n/a	with openfile(findfile(filename)) as fp:
4024	n/a	original = fp.read()
4025	n/a	msg = email.message_from_string(original)
4026	n/a	return original, msg
4027	n/a
4028	n/a	def _signed_parts_eq(self, original, result):
4029	n/a	# Extract the first mime part of each message
4030	n/a	import re
4031	n/a	repart = re.compile(r'^--([^\n]+)\n(.*?)\n--\1$', re.S \| re.M)
4032	n/a	inpart = repart.search(original).group(2)
4033	n/a	outpart = repart.search(result).group(2)
4034	n/a	self.assertEqual(outpart, inpart)
4035	n/a
4036	n/a	def test_long_headers_as_string(self):
4037	n/a	original, msg = self._msg_and_obj('msg_45.txt')
4038	n/a	result = msg.as_string()
4039	n/a	self._signed_parts_eq(original, result)
4040	n/a
4041	n/a	def test_long_headers_as_string_maxheaderlen(self):
4042	n/a	original, msg = self._msg_and_obj('msg_45.txt')
4043	n/a	result = msg.as_string(maxheaderlen=60)
4044	n/a	self._signed_parts_eq(original, result)
4045	n/a
4046	n/a	def test_long_headers_flatten(self):
4047	n/a	original, msg = self._msg_and_obj('msg_45.txt')
4048	n/a	fp = StringIO()
4049	n/a	Generator(fp).flatten(msg)
4050	n/a	result = fp.getvalue()
4051	n/a	self._signed_parts_eq(original, result)
4052	n/a
4053	n/a
4054	n/a
4055	n/a	def _testclasses():
4056	n/a	mod = sys.modules[__name__]
4057	n/a	return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
4058	n/a
4059	n/a
4060	n/a	def suite():
4061	n/a	suite = unittest.TestSuite()
4062	n/a	for testclass in _testclasses():
4063	n/a	suite.addTest(unittest.makeSuite(testclass))
4064	n/a	return suite
4065	n/a
4066	n/a
4067	n/a	def test_main():
4068	n/a	for testclass in _testclasses():
4069	n/a	run_unittest(testclass)
4070	n/a
4071	n/a
4072	n/a
4073	n/a	if __name__ == '__main__':
4074	n/a	unittest.main(defaultTest='suite')