Lines Matching refs:self
57 def test_get_all(self):
58 eq = self.assertEqual
59 msg = self._msgobj('msg_20.txt')
63 def test_getset_charset(self):
64 eq = self.assertEqual
89 def test_set_charset_from_string(self):
90 eq = self.assertEqual
96 def test_set_payload_with_charset(self):
100 self.assertEqual(msg.get_charset().input_charset, 'iso-8859-1')
102 def test_set_payload_with_8bit_data_and_charset(self):
107 self.assertEqual(msg['content-transfer-encoding'], 'base64')
108 self.assertEqual(msg.get_payload(decode=True), data)
109 self.assertEqual(msg.get_payload(), '0JDQkdCS\n')
111 def test_set_payload_with_non_ascii_and_charset_body_encoding_none(self):
117 self.assertEqual(msg['content-transfer-encoding'], '8bit')
118 self.assertEqual(msg.get_payload(decode=True), data)
120 def test_set_payload_with_8bit_data_and_charset_body_encoding_none(self):
126 self.assertEqual(msg['content-transfer-encoding'], '8bit')
127 self.assertEqual(msg.get_payload(decode=True), data)
129 def test_set_payload_to_list(self):
132 self.assertEqual(msg.get_payload(), [])
134 def test_attach_when_payload_is_string(self):
139 self.assertRaisesRegex(TypeError, "[Aa]ttach.*non-multipart",
142 def test_get_charsets(self):
143 eq = self.assertEqual
145 msg = self._msgobj('msg_08.txt')
149 msg = self._msgobj('msg_09.txt')
154 msg = self._msgobj('msg_12.txt')
159 def test_get_filename(self):
160 eq = self.assertEqual
162 msg = self._msgobj('msg_04.txt')
166 msg = self._msgobj('msg_07.txt')
170 def test_get_filename_with_name_parameter(self):
171 eq = self.assertEqual
173 msg = self._msgobj('msg_44.txt')
177 def test_get_boundary(self):
178 eq = self.assertEqual
179 msg = self._msgobj('msg_07.txt')
183 def test_set_boundary(self):
184 eq = self.assertEqual
187 msg = self._msgobj('msg_01.txt')
195 msg = self._msgobj('msg_04.txt')
201 msg = self._msgobj('msg_03.txt')
202 self.assertRaises(errors.HeaderParseError,
205 def test_make_boundary(self):
209 self.assertEqual(msg.items()[0][1], 'multipart/form-data')
212 self.assertEqual(msg.items()[0][1][:33],
216 def test_message_rfc822_only(self):
226 self.assertEqual(out.getvalue(), msgdata)
228 def test_byte_message_rfc822_only(self):
237 self.assertEqual(out.getvalue(), msgdata)
239 def test_get_decoded_payload(self):
240 eq = self.assertEqual
241 msg = self._msgobj('msg_10.txt')
261 def test_get_decoded_uu_payload(self):
262 eq = self.assertEqual
272 def test_get_payload_n_raises_on_non_multipart(self):
274 self.assertRaises(TypeError, msg.get_payload, 1)
276 def test_decoded_generator(self):
277 eq = self.assertEqual
278 msg = self._msgobj('msg_07.txt')
286 def test__contains__(self):
291 self.assertIn('from', msg)
292 self.assertIn('From', msg)
293 self.assertIn('FROM', msg)
294 self.assertIn('to', msg)
295 self.assertIn('To', msg)
296 self.assertIn('TO', msg)
298 def test_as_string(self):
299 msg = self._msgobj('msg_01.txt')
302 self.assertEqual(text, str(msg))
305 self.assertTrue(lines[0].startswith('From '))
306 self.assertEqual(text, NL.join(lines[1:]))
308 def test_as_string_policy(self):
309 msg = self._msgobj('msg_01.txt')
315 self.assertEqual(fullrepr, s.getvalue())
317 def test_nonascii_as_string_without_cte(self):
337 self.assertEqual(msg.as_string(), expected)
339 def test_nonascii_as_string_without_content_type_and_cte(self):
350 self.assertEqual(msg.as_string(), expected)
352 def test_as_bytes(self):
353 msg = self._msgobj('msg_01.txt')
356 self.assertEqual(data, bytes(msg))
359 self.assertTrue(lines[0].startswith(b'From '))
360 self.assertEqual(data, b'\n'.join(lines[1:]))
362 def test_as_bytes_policy(self):
363 msg = self._msgobj('msg_01.txt')
369 self.assertEqual(fullrepr, s.getvalue())
372 def test_bad_param(self):
374 self.assertEqual(msg.get_param('baz'), '')
376 def test_missing_filename(self):
378 self.assertEqual(msg.get_filename(), None)
380 def test_bogus_filename(self):
383 self.assertEqual(msg.get_filename(), '')
385 def test_missing_boundary(self):
387 self.assertEqual(msg.get_boundary(), None)
389 def test_get_params(self):
390 eq = self.assertEqual
406 def test_get_param_liberal(self):
409 self.assertEqual(msg.get_param('boundary'), 'CPIMSSMTPC06p5f3tG')
411 def test_get_param(self):
412 eq = self.assertEqual
429 def test_get_param_funky_continuation_lines(self):
430 msg = self._msgobj('msg_22.txt')
431 self.assertEqual(msg.get_payload(1).get_param('name'), 'wibble.JPG')
434 def test_get_param_with_semis_in_quotes(self):
437 self.assertEqual(msg.get_param('name'), 'Jim&&Jill')
438 self.assertEqual(msg.get_param('name', unquote=False),
442 def test_get_param_with_quotes(self):
445 self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
448 self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
450 def test_field_containment(self):
452 self.assertIn('header', msg)
453 self.assertIn('Header', msg)
454 self.assertIn('HEADER', msg)
455 self.assertNotIn('headerx', msg)
457 def test_set_param(self):
458 eq = self.assertEqual
474 def test_del_param(self):
475 eq = self.assertEqual
476 msg = self._msgobj('msg_05.txt')
491 def test_del_param_on_other_header(self):
495 self.assertEqual(msg['content-disposition'], 'attachment')
497 def test_del_param_on_nonexistent_header(self):
502 def test_del_nonexistent_param(self):
507 self.assertEqual(msg['Content-Type'], existing_header)
509 def test_set_type(self):
510 eq = self.assertEqual
512 self.assertRaises(ValueError, msg.set_type, 'text')
520 def test_set_type_on_other_header(self):
524 self.assertEqual(msg['x-content-type'], 'application/octet-stream')
526 def test_get_content_type_missing(self):
528 self.assertEqual(msg.get_content_type(), 'text/plain')
530 def test_get_content_type_missing_with_default_type(self):
533 self.assertEqual(msg.get_content_type(), 'message/rfc822')
535 def test_get_content_type_from_message_implicit(self):
536 msg = self._msgobj('msg_30.txt')
537 self.assertEqual(msg.get_payload(0).get_content_type(),
540 def test_get_content_type_from_message_explicit(self):
541 msg = self._msgobj('msg_28.txt')
542 self.assertEqual(msg.get_payload(0).get_content_type(),
545 def test_get_content_type_from_message_text_plain_implicit(self):
546 msg = self._msgobj('msg_03.txt')
547 self.assertEqual(msg.get_content_type(), 'text/plain')
549 def test_get_content_type_from_message_text_plain_explicit(self):
550 msg = self._msgobj('msg_01.txt')
551 self.assertEqual(msg.get_content_type(), 'text/plain')
553 def test_get_content_maintype_missing(self):
555 self.assertEqual(msg.get_content_maintype(), 'text')
557 def test_get_content_maintype_missing_with_default_type(self):
560 self.assertEqual(msg.get_content_maintype(), 'message')
562 def test_get_content_maintype_from_message_implicit(self):
563 msg = self._msgobj('msg_30.txt')
564 self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
566 def test_get_content_maintype_from_message_explicit(self):
567 msg = self._msgobj('msg_28.txt')
568 self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
570 def test_get_content_maintype_from_message_text_plain_implicit(self):
571 msg = self._msgobj('msg_03.txt')
572 self.assertEqual(msg.get_content_maintype(), 'text')
574 def test_get_content_maintype_from_message_text_plain_explicit(self):
575 msg = self._msgobj('msg_01.txt')
576 self.assertEqual(msg.get_content_maintype(), 'text')
578 def test_get_content_subtype_missing(self):
580 self.assertEqual(msg.get_content_subtype(), 'plain')
582 def test_get_content_subtype_missing_with_default_type(self):
585 self.assertEqual(msg.get_content_subtype(), 'rfc822')
587 def test_get_content_subtype_from_message_implicit(self):
588 msg = self._msgobj('msg_30.txt')
589 self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
591 def test_get_content_subtype_from_message_explicit(self):
592 msg = self._msgobj('msg_28.txt')
593 self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
595 def test_get_content_subtype_from_message_text_plain_implicit(self):
596 msg = self._msgobj('msg_03.txt')
597 self.assertEqual(msg.get_content_subtype(), 'plain')
599 def test_get_content_subtype_from_message_text_plain_explicit(self):
600 msg = self._msgobj('msg_01.txt')
601 self.assertEqual(msg.get_content_subtype(), 'plain')
603 def test_get_content_maintype_error(self):
606 self.assertEqual(msg.get_content_maintype(), 'text')
608 def test_get_content_subtype_error(self):
611 self.assertEqual(msg.get_content_subtype(), 'plain')
613 def test_replace_header(self):
614 eq = self.assertEqual
628 self.assertRaises(KeyError, msg.replace_header, 'Fourth', 'Missing')
630 def test_get_content_disposition(self):
632 self.assertIsNone(msg.get_content_disposition())
635 self.assertEqual(msg.get_content_disposition(), 'attachment')
637 self.assertEqual(msg.get_content_disposition(), 'inline')
639 self.assertEqual(msg.get_content_disposition(), 'inline')
642 def test_broken_base64_payload(self):
648 self.assertEqual(msg.get_payload(decode=True),
651 self.assertIsInstance(msg.defects[0],
654 def test_broken_unicode_payload(self):
662 self.assertEqual(msg.get_payload(decode=True),
665 def test_questionable_bytes_payload(self):
673 self.assertEqual(msg.get_payload(decode=True), x)
676 def test_ascii_add_header(self):
680 self.assertEqual('attachment; filename="bud.gif"',
683 def test_noascii_add_header(self):
687 self.assertEqual(
691 def test_nonascii_add_header_via_triple(self):
695 self.assertEqual(
699 def test_ascii_add_header_with_tspecial(self):
703 self.assertEqual(
707 def test_nonascii_add_header_with_tspecial(self):
711 self.assertEqual(
715 def test_binary_quopri_payload(self):
721 self.assertEqual(
726 def test_binary_base64_payload(self):
732 self.assertEqual(
737 def test_binary_uuencode_payload(self):
744 self.assertEqual(
751 def test_add_header_with_name_only_param(self):
754 self.assertEqual("inline; foo-bar", msg['Content-Disposition'])
756 def test_add_header_with_no_value(self):
759 self.assertEqual('', msg['X-Status'])
763 def test_embedded_header_via_Header_rejected(self):
766 self.assertRaises(errors.HeaderParseError, msg.as_string)
768 def test_embedded_header_via_string_rejected(self):
771 self.assertRaises(errors.HeaderParseError, msg.as_string)
773 def test_unicode_header_defaults_to_utf8_encoding(self):
777 self.assertEqual(str(m),textwrap.dedent("""\
786 def test_unicode_body_defaults_to_utf8_encoding(self):
789 self.assertEqual(str(m),textwrap.dedent("""\
801 def test_EncodersEncode_base64(self):
808 self.assertLessEqual(max([ len(x) for x in lines ]), 76)
810 def test_encode_empty_payload(self):
811 eq = self.assertEqual
816 def test_default_cte(self):
817 eq = self.assertEqual
828 def test_encode7or8bit(self):
832 eq = self.assertEqual
843 def test_qp_encode_latin1(self):
845 self.assertEqual(str(msg), textwrap.dedent("""\
853 def test_qp_encode_non_latin1(self):
856 self.assertEqual(str(msg), textwrap.dedent("""\
870 def test_split_long_continuation(self):
871 eq = self.ndiffAssertEqual
890 def test_another_long_almost_unsplittable_header(self):
891 eq = self.ndiffAssertEqual
907 def test_long_nonstring(self):
908 eq = self.ndiffAssertEqual
961 def test_long_header_encode(self):
962 eq = self.ndiffAssertEqual
970 def test_long_header_encode_with_tab_continuation_is_just_a_hint(self):
971 eq = self.ndiffAssertEqual
980 def test_long_header_encode_with_tab_continuation(self):
981 eq = self.ndiffAssertEqual
990 def test_header_encode_with_different_output_charset(self):
992 self.assertEqual(h.encode(), "=?iso-2022-jp?b?GyRCSjgbKEI=?=")
994 def test_long_header_encode_with_different_output_charset(self):
1002 self.assertEqual(h.encode(), res)
1004 def test_header_splitter(self):
1005 eq = self.ndiffAssertEqual
1024 def test_no_semis_header_splitter(self):
1025 eq = self.ndiffAssertEqual
1040 def test_last_split_chunk_does_not_fit(self):
1041 eq = self.ndiffAssertEqual
1049 def test_splittable_leading_char_followed_by_overlong_unsplittable(self):
1050 eq = self.ndiffAssertEqual
1058 def test_multiple_splittable_leading_char_followed_by_overlong_unsplittable(self):
1059 eq = self.ndiffAssertEqual
1067 def test_trailing_splittable_on_overlong_unsplittable(self):
1068 eq = self.ndiffAssertEqual
1074 def test_trailing_splittable_on_overlong_unsplittable_with_leading_splittable(self):
1075 eq = self.ndiffAssertEqual
1083 def test_long_header_with_multiple_sequential_split_chars(self):
1084 eq = self.ndiffAssertEqual
1091 def test_splitter_split_on_punctuation_only_if_fws_with_header(self):
1092 eq = self.ndiffAssertEqual
1098 def test_leading_splittable_in_the_middle_just_before_overlong_last_part(self):
1099 eq = self.ndiffAssertEqual
1109 def test_overlong_last_part_followed_by_split_point(self):
1110 eq = self.ndiffAssertEqual
1116 def test_multiline_with_overlong_parts_separated_by_two_split_points(self):
1117 eq = self.ndiffAssertEqual
1127 def test_multiline_with_overlong_last_part_followed_by_split_point(self):
1128 eq = self.ndiffAssertEqual
1138 def test_long_header_with_whitespace_runs(self):
1139 eq = self.ndiffAssertEqual
1155 def test_long_run_with_semi_header_splitter(self):
1156 eq = self.ndiffAssertEqual
1172 def test_splitter_split_on_punctuation_only_if_fws(self):
1173 eq = self.ndiffAssertEqual
1190 def test_no_split_long_header(self):
1191 eq = self.ndiffAssertEqual
1202 def test_splitting_multiple_long_lines(self):
1203 eq = self.ndiffAssertEqual
1224 def test_splitting_first_line_only_is_long(self):
1225 eq = self.ndiffAssertEqual
1240 def test_long_8bit_header(self):
1241 eq = self.ndiffAssertEqual
1260 def test_long_8bit_header_no_charset(self):
1261 eq = self.ndiffAssertEqual
1281 def test_long_to_header(self):
1282 eq = self.ndiffAssertEqual
1298 def test_long_line_after_append(self):
1299 eq = self.ndiffAssertEqual
1307 def test_shorter_line_with_append(self):
1308 eq = self.ndiffAssertEqual
1315 def test_long_field_name(self):
1316 eq = self.ndiffAssertEqual
1330 def test_long_received_header(self):
1338 self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
1348 def test_string_headerinst_eq(self):
1357 self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
1367 def test_long_unbreakable_lines_with_continuation(self):
1368 eq = self.ndiffAssertEqual
1391 def test_another_long_multiline_header(self):
1392 eq = self.ndiffAssertEqual
1404 def test_long_lines_with_different_header(self):
1405 eq = self.ndiffAssertEqual
1423 def test_long_rfc2047_header_with_embedded_fws(self):
1430 self.assertEqual(h.encode()+'\n', textwrap.dedent("""\
1440 def setUp(self):
1441 self.msg = Message()
1442 self.msg['From'] = 'aaa@bbb.org'
1443 self.msg.set_payload("""\
1448 def test_mangled_from(self):
1451 g.flatten(self.msg)
1452 self.assertEqual(s.getvalue(), """\
1459 def test_dont_mangle_from(self):
1462 g.flatten(self.msg)
1463 self.assertEqual(s.getvalue(), """\
1470 def test_mangle_from_in_preamble_and_epilog(self):
1490 self.assertEqual(len([1 for x in s.getvalue().split('\n')
1493 def test_mangled_from_with_bad_bytes(self):
1505 self.assertEqual(b.getvalue(), source + b'>From R\xc3\xb6lli\n')
1507 def test_multipart_with_bad_bytes_in_cte(self):
1519 def _make_audio(self, ext):
1521 self._audiodata = fp.read()
1522 self._au = MIMEAudio(self._audiodata)
1524 def test_guess_minor_type(self):
1531 self._make_audio(ext)
1533 self.assertEqual(self._au.get_content_type(), f'audio/{subtype}')
1535 def test_encoding(self):
1536 self._make_audio('au')
1537 payload = self._au.get_payload()
1538 self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
1539 self._audiodata)
1541 def test_checkSetMinor(self):
1542 self._make_audio('au')
1543 au = MIMEAudio(self._audiodata, 'fish')
1544 self.assertEqual(au.get_content_type(), 'audio/fish')
1546 def test_add_header(self):
1547 self._make_audio('au')
1548 eq = self.assertEqual
1549 self._au.add_header('Content-Disposition', 'attachment',
1551 eq(self._au['content-disposition'],
1553 eq(self._au.get_params(header='content-disposition'),
1555 eq(self._au.get_param('filename', header='content-disposition'),
1558 eq(self._au.get_param('attachment', header='content-disposition'), '')
1559 self.assertIs(self._au.get_param(
1563 self.assertIs(self._au.get_param('foobar', missing), missing)
1564 self.assertIs(self._au.get_param('attachment', missing,
1571 def _make_image(self, ext):
1573 self._imgdata = fp.read()
1574 self._im = MIMEImage(self._imgdata)
1576 def test_guess_minor_type(self):
1592 self._make_image(ext)
1594 self.assertEqual(self._im.get_content_type(), f'image/{subtype}')
1596 def test_encoding(self):
1597 self._make_image('gif')
1598 payload = self._im.get_payload()
1599 self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
1600 self._imgdata)
1602 def test_checkSetMinor(self):
1603 self._make_image('gif')
1604 im = MIMEImage(self._imgdata, 'fish')
1605 self.assertEqual(im.get_content_type(), 'image/fish')
1607 def test_add_header(self):
1608 self._make_image('gif')
1609 eq = self.assertEqual
1610 self._im.add_header('Content-Disposition', 'attachment',
1612 eq(self._im['content-disposition'],
1614 eq(self._im.get_params(header='content-disposition'),
1616 eq(self._im.get_param('filename', header='content-disposition'),
1619 eq(self._im.get_param('attachment', header='content-disposition'), '')
1620 self.assertIs(self._im.get_param('foo', failobj=missing,
1623 self.assertIs(self._im.get_param('foobar', missing), missing)
1624 self.assertIs(self._im.get_param('attachment', missing,
1630 def test_headers(self):
1631 eq = self.assertEqual
1636 def test_body(self):
1637 eq = self.assertEqual
1644 def test_binary_body_with_encode_7or8bit(self):
1649 self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
1650 self.assertEqual(msg.get_payload(decode=True), bytesdata)
1651 self.assertEqual(msg['Content-Transfer-Encoding'], '8bit')
1657 self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
1658 self.assertEqual(msg2.get_payload(decode=True), bytesdata)
1659 self.assertEqual(msg2['Content-Transfer-Encoding'], '8bit')
1661 def test_binary_body_with_encode_noop(self):
1668 self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
1669 self.assertEqual(msg.get_payload(decode=True), bytesdata)
1675 self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
1676 self.assertEqual(msg2.get_payload(decode=True), bytesdata)
1678 def test_binary_body_with_unicode_linend_encode_noop(self):
1682 self.assertEqual(msg.get_payload(decode=True), bytesdata)
1688 self.assertEqual(msg2.get_payload(decode=True), bytesdata)
1690 def test_binary_body_with_encode_quopri(self):
1694 self.assertEqual(msg.get_payload(), '=FA=FB=FC=FD=FE=FF=20')
1695 self.assertEqual(msg.get_payload(decode=True), bytesdata)
1696 self.assertEqual(msg['Content-Transfer-Encoding'], 'quoted-printable')
1702 self.assertEqual(msg.get_payload(), '=FA=FB=FC=FD=FE=FF=20')
1703 self.assertEqual(msg2.get_payload(decode=True), bytesdata)
1704 self.assertEqual(msg2['Content-Transfer-Encoding'], 'quoted-printable')
1706 def test_binary_body_with_encode_base64(self):
1709 self.assertEqual(msg.get_payload(), '+vv8/f7/\n')
1710 self.assertEqual(msg.get_payload(decode=True), bytesdata)
1716 self.assertEqual(msg.get_payload(), '+vv8/f7/\n')
1717 self.assertEqual(msg2.get_payload(decode=True), bytesdata)
1722 def setUp(self):
1723 self._msg = MIMEText('hello there')
1725 def test_types(self):
1726 eq = self.assertEqual
1727 eq(self._msg.get_content_type(), 'text/plain')
1728 eq(self._msg.get_param('charset'), 'us-ascii')
1730 self.assertIs(self._msg.get_param('foobar', missing), missing)
1731 self.assertIs(self._msg.get_param('charset', missing, header='foobar'),
1734 def test_payload(self):
1735 self.assertEqual(self._msg.get_payload(), 'hello there')
1736 self.assertFalse(self._msg.is_multipart())
1738 def test_charset(self):
1739 eq = self.assertEqual
1751 def test_7bit_input(self):
1752 eq = self.assertEqual
1757 def test_7bit_input_no_charset(self):
1758 eq = self.assertEqual
1762 self.assertIn('hello there', msg.as_string())
1764 def test_utf8_input(self):
1766 eq = self.assertEqual
1774 def test_utf8_input_no_charset(self):
1776 self.assertRaises(UnicodeEncodeError, MIMEText, teststr)
1782 def setUp(self):
1814 self._msg = container
1815 self._im = image
1816 self._txt = intro
1818 def test_hierarchy(self):
1820 eq = self.assertEqual
1821 raises = self.assertRaises
1823 m = self._msg
1824 self.assertTrue(m.is_multipart())
1830 self.assertIs(m0, self._txt)
1831 self.assertIs(m1, self._im)
1833 self.assertFalse(m0.is_multipart())
1834 self.assertFalse(m1.is_multipart())
1836 def test_empty_multipart_idempotent(self):
1851 self.ndiffAssertEqual(text, msg.as_string())
1853 def test_no_parts_in_a_multipart_with_none_epilogue(self):
1859 self.ndiffAssertEqual(outer.as_string(), '''\
1871 def test_no_parts_in_a_multipart_with_empty_epilogue(self):
1879 self.ndiffAssertEqual(outer.as_string(), '''\
1892 def test_one_part_in_a_multipart(self):
1893 eq = self.ndiffAssertEqual
1917 def test_seq_parts_in_a_multipart_with_empty_preamble(self):
1918 eq = self.ndiffAssertEqual
1945 def test_seq_parts_in_a_multipart_with_none_preamble(self):
1946 eq = self.ndiffAssertEqual
1972 def test_seq_parts_in_a_multipart_with_none_epilogue(self):
1973 eq = self.ndiffAssertEqual
1999 def test_seq_parts_in_a_multipart_with_empty_epilogue(self):
2000 eq = self.ndiffAssertEqual
2026 def test_seq_parts_in_a_multipart_with_nl_epilogue(self):
2027 eq = self.ndiffAssertEqual
2053 def test_message_external_body(self):
2054 eq = self.assertEqual
2055 msg = self._msgobj('msg_36.txt')
2066 def test_double_boundary(self):
2070 msg = self._msgobj('msg_37.txt')
2071 self.assertEqual(len(msg.get_payload()), 3)
2073 def test_nested_inner_contains_outer_boundary(self):
2074 eq = self.ndiffAssertEqual
2079 msg = self._msgobj('msg_38.txt')
2092 def test_nested_with_same_boundary(self):
2093 eq = self.ndiffAssertEqual
2097 msg = self._msgobj('msg_39.txt')
2109 def test_boundary_in_non_multipart(self):
2110 msg = self._msgobj('msg_40.txt')
2111 self.assertEqual(msg.as_string(), '''\
2124 def test_boundary_with_leading_space(self):
2125 eq = self.assertEqual
2139 self.assertTrue(msg.is_multipart())
2143 def test_boundary_without_trailing_newline(self):
2155 self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
2157 def test_mimebase_default_policy(self):
2159 self.assertIs(m.policy, email.policy.compat32)
2161 def test_mimebase_custom_policy(self):
2163 self.assertIs(m.policy, email.policy.default)
2168 def test_parse_missing_minor_type(self):
2169 eq = self.assertEqual
2170 msg = self._msgobj('msg_14.txt')
2176 def test_same_boundary_inner_outer(self):
2177 msg = self._msgobj('msg_15.txt')
2180 self.assertTrue(hasattr(inner, 'defects'))
2181 self.assertEqual(len(inner.defects), 1)
2182 self.assertIsInstance(inner.defects[0],
2186 def test_multipart_no_boundary(self):
2187 msg = self._msgobj('msg_25.txt')
2188 self.assertIsInstance(msg.get_payload(), str)
2189 self.assertEqual(len(msg.defects), 2)
2190 self.assertIsInstance(msg.defects[0],
2192 self.assertIsInstance(msg.defects[1],
2219 def test_multipart_invalid_cte(self):
2220 msg = self._str_msg(
2221 self.multipart_msg.format("\nContent-Transfer-Encoding: base64"))
2222 self.assertEqual(len(msg.defects), 1)
2223 self.assertIsInstance(msg.defects[0],
2227 def test_multipart_no_cte_no_defect(self):
2228 msg = self._str_msg(self.multipart_msg.format(''))
2229 self.assertEqual(len(msg.defects), 0)
2232 def test_multipart_valid_cte_no_defect(self):
2234 msg = self._str_msg(
2235 self.multipart_msg.format(
2237 self.assertEqual(len(msg.defects), 0)
2240 def test_invalid_content_type(self):
2241 eq = self.assertEqual
2242 neq = self.ndiffAssertEqual
2261 def test_no_start_boundary(self):
2262 eq = self.ndiffAssertEqual
2263 msg = self._msgobj('msg_31.txt')
2278 def test_no_separating_blank_line(self):
2279 eq = self.ndiffAssertEqual
2280 msg = self._msgobj('msg_35.txt')
2290 def test_lying_multipart(self):
2291 msg = self._msgobj('msg_41.txt')
2292 self.assertTrue(hasattr(msg, 'defects'))
2293 self.assertEqual(len(msg.defects), 2)
2294 self.assertIsInstance(msg.defects[0],
2296 self.assertIsInstance(msg.defects[1],
2300 def test_missing_start_boundary(self):
2301 outer = self._msgobj('msg_42.txt')
2311 self.assertEqual(len(bad.defects), 1)
2312 self.assertIsInstance(bad.defects[0],
2316 def test_first_line_is_continuation_header(self):
2317 eq = self.assertEqual
2323 self.assertDefectsEqual(msg.defects,
2328 def test_missing_header_body_separator(self):
2333 msg = self._str_msg('Subject: test\nnot a header\nTo: abc\n\nb\n')
2334 self.assertEqual(msg.keys(), ['Subject'])
2335 self.assertEqual(msg.get_payload(), 'not a header\nTo: abc\n\nb\n')
2336 self.assertDefectsEqual(msg.defects,
2342 def test_rfc2047_multiline(self):
2343 eq = self.assertEqual
2355 self.ndiffAssertEqual(header.encode(maxlinelen=76), """\
2359 def test_whitespace_keeper_unicode(self):
2360 eq = self.assertEqual
2368 def test_whitespace_keeper_unicode_2(self):
2369 eq = self.assertEqual
2377 def test_rfc2047_missing_whitespace(self):
2380 self.assertEqual(dh, [(b'Sm', None), (b'\xf6', 'iso-8859-1'),
2384 def test_rfc2047_with_whitespace(self):
2387 self.assertEqual(dh, [(b'Sm ', None), (b'\xf6', 'iso-8859-1'),
2391 def test_rfc2047_B_bad_padding(self):
2399 self.assertEqual(dh, [(a, 'iso-8859-1')])
2401 def test_rfc2047_Q_invalid_digits(self):
2404 self.assertEqual(decode_header(s),
2407 def test_rfc2047_rfc2047_1(self):
2410 self.assertEqual(decode_header(s),
2413 def test_rfc2047_rfc2047_2(self):
2416 self.assertEqual(decode_header(s),
2419 def test_rfc2047_rfc2047_3(self):
2422 self.assertEqual(decode_header(s),
2425 def test_rfc2047_rfc2047_4(self):
2428 self.assertEqual(decode_header(s),
2431 def test_rfc2047_rfc2047_5a(self):
2434 self.assertEqual(decode_header(s),
2437 def test_rfc2047_rfc2047_5b(self):
2440 self.assertEqual(decode_header(s),
2443 def test_rfc2047_rfc2047_6(self):
2446 self.assertEqual(decode_header(s),
2449 def test_rfc2047_rfc2047_7(self):
2452 self.assertEqual(decode_header(s),
2455 self.assertEqual(make_header(decode_header(s)).encode(), s.lower())
2456 self.assertEqual(str(make_header(decode_header(s))), '(a b)')
2458 def test_multiline_header(self):
2460 self.assertEqual(decode_header(s),
2463 self.assertEqual(make_header(decode_header(s)).encode(),
2465 self.assertEqual(str(make_header(decode_header(s))),
2471 def setUp(self):
2473 self._text = fp.read()
2475 def test_type_error(self):
2476 self.assertRaises(TypeError, MIMEMessage, 'a plain string')
2478 def test_valid_argument(self):
2479 eq = self.assertEqual
2486 self.assertIsInstance(payload, list)
2489 self.assertIs(subpart, m)
2492 def test_bad_multipart(self):
2498 self.assertRaises(errors.MultipartConversionError, r.attach, msg2)
2500 def test_generate(self):
2510 self.assertEqual(s.getvalue(), """\
2520 def test_parse_message_rfc822(self):
2521 eq = self.assertEqual
2522 msg = self._msgobj('msg_11.txt')
2525 self.assertIsInstance(payload, list)
2528 self.assertIsInstance(submsg, Message)
2532 def test_dsn(self):
2533 eq = self.assertEqual
2535 msg = self._msgobj('msg_16.txt')
2537 self.assertTrue(msg.is_multipart())
2566 self.assertIsInstance(dsn1, Message)
2572 self.assertIsInstance(dsn2, Message)
2581 self.assertIsInstance(payload, list)
2584 self.assertIsInstance(subsubpart, Message)
2589 def test_epilogue(self):
2590 eq = self.ndiffAssertEqual
2609 def test_no_nl_preamble(self):
2610 eq = self.ndiffAssertEqual
2644 def test_default_type(self):
2645 eq = self.assertEqual
2661 def test_default_type_with_explicit_container_type(self):
2662 eq = self.assertEqual
2678 def test_default_type_non_parsed(self):
2679 eq = self.assertEqual
2680 neq = self.ndiffAssertEqual
2752 def test_mime_attachments_in_constructor(self):
2753 eq = self.assertEqual
2761 def test_default_multipart_constructor(self):
2763 self.assertTrue(msg.is_multipart())
2765 def test_multipart_default_policy(self):
2769 self.assertEqual(msg.get_all('to'), ['a@b.com', 'c@d.com'])
2771 def test_multipart_custom_policy(self):
2774 with self.assertRaises(ValueError) as cm:
2776 self.assertEqual(str(cm.exception),
2782 def test_nonmultipart_is_not_multipart(self):
2784 self.assertFalse(msg.is_multipart())
2786 def test_attach_raises_exception(self):
2790 self.assertRaises(errors.MultipartConversionError, r.attach, msg)
2802 def _msgobj(self, filename):
2808 def _idempotent(self, msg, text, unixfrom=False):
2809 eq = self.ndiffAssertEqual
2815 def test_parse_text_message(self):
2816 eq = self.assertEqual
2817 msg, text = self._msgobj('msg_01.txt')
2825 self._idempotent(msg, text)
2827 def test_parse_untyped_message(self):
2828 eq = self.assertEqual
2829 msg, text = self._msgobj('msg_03.txt')
2833 self._idempotent(msg, text)
2835 def test_simple_multipart(self):
2836 msg, text = self._msgobj('msg_04.txt')
2837 self._idempotent(msg, text)
2839 def test_MIME_digest(self):
2840 msg, text = self._msgobj('msg_02.txt')
2841 self._idempotent(msg, text)
2843 def test_long_header(self):
2844 msg, text = self._msgobj('msg_27.txt')
2845 self._idempotent(msg, text)
2847 def test_MIME_digest_with_part_headers(self):
2848 msg, text = self._msgobj('msg_28.txt')
2849 self._idempotent(msg, text)
2851 def test_mixed_with_image(self):
2852 msg, text = self._msgobj('msg_06.txt')
2853 self._idempotent(msg, text)
2855 def test_multipart_report(self):
2856 msg, text = self._msgobj('msg_05.txt')
2857 self._idempotent(msg, text)
2859 def test_dsn(self):
2860 msg, text = self._msgobj('msg_16.txt')
2861 self._idempotent(msg, text)
2863 def test_preamble_epilogue(self):
2864 msg, text = self._msgobj('msg_21.txt')
2865 self._idempotent(msg, text)
2867 def test_multipart_one_part(self):
2868 msg, text = self._msgobj('msg_23.txt')
2869 self._idempotent(msg, text)
2871 def test_multipart_no_parts(self):
2872 msg, text = self._msgobj('msg_24.txt')
2873 self._idempotent(msg, text)
2875 def test_no_start_boundary(self):
2876 msg, text = self._msgobj('msg_31.txt')
2877 self._idempotent(msg, text)
2879 def test_rfc2231_charset(self):
2880 msg, text = self._msgobj('msg_32.txt')
2881 self._idempotent(msg, text)
2883 def test_more_rfc2231_parameters(self):
2884 msg, text = self._msgobj('msg_33.txt')
2885 self._idempotent(msg, text)
2887 def test_text_plain_in_a_multipart_digest(self):
2888 msg, text = self._msgobj('msg_34.txt')
2889 self._idempotent(msg, text)
2891 def test_nested_multipart_mixeds(self):
2892 msg, text = self._msgobj('msg_12a.txt')
2893 self._idempotent(msg, text)
2895 def test_message_external_body_idempotent(self):
2896 msg, text = self._msgobj('msg_36.txt')
2897 self._idempotent(msg, text)
2899 def test_message_delivery_status(self):
2900 msg, text = self._msgobj('msg_43.txt')
2901 self._idempotent(msg, text, unixfrom=True)
2903 def test_message_signed_idempotent(self):
2904 msg, text = self._msgobj('msg_45.txt')
2905 self._idempotent(msg, text)
2907 def test_content_type(self):
2908 eq = self.assertEqual
2910 msg, text = self._msgobj('msg_05.txt')
2918 eq(msg.preamble, 'This is a MIME-encapsulated message.' + self.linesep)
2919 eq(msg.epilogue, self.linesep)
2924 eq(msg1.get_payload(), 'Yadda yadda yadda' + self.linesep)
2927 eq(msg2.get_payload(), 'Yadda yadda yadda' + self.linesep)
2930 self.assertIsInstance(msg3, Message)
2932 self.assertIsInstance(payload, list)
2935 self.assertIsInstance(msg4, Message)
2936 eq(msg4.get_payload(), 'Yadda yadda yadda' + self.linesep)
2938 def test_parser(self):
2939 eq = self.assertEqual
2940 msg, text = self._msgobj('msg_06.txt')
2946 self.assertIsInstance(payload, list)
2949 self.assertIsInstance(msg1, Message)
2951 self.assertIsInstance(msg1.get_payload(), str)
2952 eq(msg1.get_payload(), self.linesep)
2958 def test_message_from_string(self):
2967 self.assertEqual(text, s.getvalue())
2969 def test_message_from_file(self):
2979 self.assertEqual(text, s.getvalue())
2981 def test_message_from_string_with_class(self):
2990 self.assertIsInstance(msg, MyMessage)
2996 self.assertIsInstance(subpart, MyMessage)
2998 def test_message_from_file_with_class(self):
3005 self.assertIsInstance(msg, MyMessage)
3010 self.assertIsInstance(subpart, MyMessage)
3012 def test_custom_message_does_not_require_arguments(self):
3014 def __init__(self):
3016 msg = self._str_msg("Subject: test\n\ntest", MyMessage)
3017 self.assertIsInstance(msg, MyMessage)
3019 def test__all__(self):
3021 self.assertEqual(sorted(module.__all__), [
3029 def test_formatdate(self):
3031 self.assertEqual(utils.parsedate(utils.formatdate(now))[:6],
3034 def test_formatdate_localtime(self):
3036 self.assertEqual(
3040 def test_formatdate_usegmt(self):
3042 self.assertEqual(
3045 self.assertEqual(
3050 def test_parsedate_returns_None_for_invalid_strings(self):
3065 with self.subTest(dtstr=dtstr):
3066 self.assertIsNone(utils.parsedate(dtstr))
3067 self.assertIsNone(utils.parsedate_tz(dtstr))
3069 self.assertIsNone(utils.parsedate(None))
3070 self.assertIsNone(utils.parsedate_tz(None))
3072 def test_parsedate_compact(self):
3073 self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26 +0800'),
3076 self.assertEqual(utils.parsedate_tz('Wed,3 Apr 2002 14:58:26 +0800'),
3079 self.assertEqual(utils.parsedate_tz('Wed 3 Apr 2002 14:58:26 +0800'),
3082 def test_parsedate_no_dayofweek(self):
3083 eq = self.assertEqual
3089 def test_parsedate_no_space_before_positive_offset(self):
3090 self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26+0800'),
3093 def test_parsedate_no_space_before_negative_offset(self):
3095 self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26-0800'),
3098 def test_parsedate_accepts_time_with_dots(self):
3099 eq = self.assertEqual
3105 def test_parsedate_rfc_850(self):
3106 self.assertEqual(utils.parsedate_tz('Friday, 19-Nov-82 16:14:55 EST'),
3109 def test_parsedate_no_seconds(self):
3110 self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58 +0800'),
3113 def test_parsedate_dot_time_delimiter(self):
3114 self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14.58.26 +0800'),
3116 self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14.58 +0800'),
3119 def test_parsedate_acceptable_to_time_functions(self):
3120 eq = self.assertEqual
3130 def test_mktime_tz(self):
3131 self.assertEqual(utils.mktime_tz((1970, 1, 1, 0, 0, 0,
3133 self.assertEqual(utils.mktime_tz((1970, 1, 1, 0, 0, 0,
3136 def test_parsedate_y2k(self):
3144 self.assertEqual(utils.parsedate_tz('25 Feb 03 13:47:26 -0800'),
3146 self.assertEqual(utils.parsedate_tz('25 Feb 71 13:47:26 -0800'),
3149 def test_parseaddr_empty(self):
3150 self.assertEqual(utils.parseaddr('<>'), ('', ''))
3151 self.assertEqual(utils.formataddr(utils.parseaddr('<>')), '')
3153 def test_parseaddr_multiple_domains(self):
3154 self.assertEqual(
3158 self.assertEqual(
3162 self.assertEqual(
3167 def test_noquote_dump(self):
3168 self.assertEqual(
3172 def test_escape_dump(self):
3173 self.assertEqual(
3176 self.assertEqual(
3181 self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
3183 def test_escape_backslashes(self):
3184 self.assertEqual(
3189 self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
3191 def test_quotes_unicode_names(self):
3197 self.assertEqual(utils.formataddr((name, addr)), utf8_base64)
3198 self.assertEqual(utils.formataddr((name, addr), 'iso-8859-1'),
3201 def test_accepts_any_charset_like_object(self):
3208 def header_encode(self, string):
3212 self.assertEqual(utils.formataddr((name, addr), mock), mock_expected)
3213 self.assertEqual(utils.formataddr((name, addr), Charset('utf-8')),
3216 def test_invalid_charset_like_object_raises_error(self):
3222 self.assertRaises(AttributeError, utils.formataddr, (name, addr),
3225 def test_unicode_address_raises_error(self):
3228 self.assertRaises(UnicodeError, utils.formataddr, (None, addr))
3229 self.assertRaises(UnicodeError, utils.formataddr, ("Name", addr))
3231 def test_name_with_dot(self):
3235 self.assertEqual(utils.parseaddr(x), (a, b))
3236 self.assertEqual(utils.parseaddr(y), (a, b))
3238 self.assertEqual(utils.formataddr((a, b)), y)
3240 def test_parseaddr_preserves_quoted_pairs_in_addresses(self):
3250 eq = self.assertEqual
3258 def test_parseaddr_preserves_spaces_in_local_part(self):
3265 self.assertEqual(('', "merwok wok@xample.com"),
3267 self.assertEqual(('', "merwok wok@xample.com"),
3269 self.assertEqual(('', "merwok wok@xample.com"),
3271 self.assertEqual(('', 'merwok"wok" wok@xample.com'),
3273 self.assertEqual(('', 'merwok.wok.wok@xample.com'),
3276 def test_formataddr_does_not_quote_parens_in_quoted_string(self):
3281 self.assertEqual(utils.parseaddr(addrstr), addr)
3282 self.assertEqual(utils.formataddr(addr), addrstr)
3285 def test_multiline_from_comment(self):
3289 self.assertEqual(utils.parseaddr(x), ('Foo Bar', 'foo@example.com'))
3291 def test_quote_dump(self):
3292 self.assertEqual(
3296 def test_charset_richcomparisons(self):
3297 eq = self.assertEqual
3298 ne = self.assertNotEqual
3316 def test_getaddresses(self):
3317 eq = self.assertEqual
3323 def test_getaddresses_nasty(self):
3324 eq = self.assertEqual
3333 def test_getaddresses_embedded_comment(self):
3335 eq = self.assertEqual
3339 def test_getaddresses_header_obj(self):
3342 self.assertEqual(addrs[0][1], 'aperson@dom.ain')
3345 def test_make_msgid_collisions(self):
3348 def run(self):
3350 self.msgids = []
3351 append = self.msgids.append
3362 self.assertEqual(len(set(all_ids)), len(all_ids))
3364 def test_utils_quote_unquote(self):
3365 eq = self.assertEqual
3371 def test_get_body_encoding_with_bogus_charset(self):
3373 self.assertEqual(charset.get_body_encoding(), 'base64')
3375 def test_get_body_encoding_with_uppercase_charset(self):
3376 eq = self.assertEqual
3401 def test_charsets_case_insensitive(self):
3404 self.assertEqual(lc.get_body_encoding(), uc.get_body_encoding())
3406 def test_partial_falls_inside_message_delivery_status(self):
3407 eq = self.ndiffAssertEqual
3412 msg = self._msgobj('msg_43.txt')
3448 def test_make_msgid_domain(self):
3449 self.assertEqual(
3453 def test_make_msgid_idstring(self):
3454 self.assertEqual(
3459 def test_make_msgid_default_domain(self):
3462 self.assertTrue(
3466 def test_Generator_linend(self):
3475 self.assertEqual(s.getvalue(), msgtxt_nl)
3477 def test_BytesGenerator_linend(self):
3486 self.assertEqual(s.getvalue().decode('ascii'), msgtxt)
3488 def test_BytesGenerator_linend_with_non_ascii(self):
3498 self.assertEqual(s.getvalue(), msgtxt)
3500 def test_mime_classes_policy_argument(self):
3514 with self.subTest(cls=cls.__name__, policy='compat32'):
3516 self.assertIs(m.policy, email.policy.compat32)
3517 with self.subTest(cls=cls.__name__, policy='default'):
3519 self.assertIs(m.policy, email.policy.default)
3524 def test_body_line_iterator(self):
3525 eq = self.assertEqual
3526 neq = self.ndiffAssertEqual
3528 msg = self._msgobj('msg_01.txt')
3534 msg = self._msgobj('msg_02.txt')
3541 def test_typed_subpart_iterator(self):
3542 eq = self.assertEqual
3543 msg = self._msgobj('msg_04.txt')
3558 def test_typed_subpart_iterator_default_type(self):
3559 eq = self.assertEqual
3560 msg = self._msgobj('msg_03.txt')
3577 def test_pushCR_LF(self):
3603 self.assertEqual(n, n1)
3604 self.assertEqual(len(om), nt)
3605 self.assertEqual(''.join([il for il, n in imt]), ''.join(om))
3607 def test_push_random(self):
3623 self.assertEqual(lines, target)
3628 def parse(self, chunks):
3634 def test_empty_header_name_handled(self):
3636 msg = self.parse("First: val\n: bad\nSecond: val")
3637 self.assertEqual(msg['First'], 'val')
3638 self.assertEqual(msg['Second'], 'val')
3640 def test_newlines(self):
3641 m = self.parse(['a:\nb:\rc:\r\nd:\n'])
3642 self.assertEqual(m.keys(), ['a', 'b', 'c', 'd'])
3643 m = self.parse(['a:\nb:\rc:\r\nd:'])
3644 self.assertEqual(m.keys(), ['a', 'b', 'c', 'd'])
3645 m = self.parse(['a:\rb', 'c:\n'])
3646 self.assertEqual(m.keys(), ['a', 'bc'])
3647 m = self.parse(['a:\r', 'b:\n'])
3648 self.assertEqual(m.keys(), ['a', 'b'])
3649 m = self.parse(['a:\r', '\nb:\n'])
3650 self.assertEqual(m.keys(), ['a', 'b'])
3653 m = self.parse(['a:\x85b:\u2028c:\n'])
3654 self.assertEqual(m.items(), [('a', '\x85b:\u2028c:')])
3655 m = self.parse(['a:\r', 'b:\x85', 'c:\n'])
3656 self.assertEqual(m.items(), [('a', ''), ('b', '\x85c:')])
3658 def test_long_lines(self):
3661 m = self.parse(['a:b\n\n'] + ['x'*M] * N)
3662 self.assertEqual(m.items(), [('a', 'b')])
3663 self.assertEqual(m.get_payload(), 'x'*M*N)
3664 m = self.parse(['a:b\r\r'] + ['x'*M] * N)
3665 self.assertEqual(m.items(), [('a', 'b')])
3666 self.assertEqual(m.get_payload(), 'x'*M*N)
3667 m = self.parse(['a:b\r\r'] + ['x'*M+'\x85'] * N)
3668 self.assertEqual(m.items(), [('a', 'b')])
3669 self.assertEqual(m.get_payload(), ('x'*M+'\x85')*N)
3670 m = self.parse(['a:\r', 'b: '] + ['x'*M] * N)
3671 self.assertEqual(m.items(), [('a', ''), ('b', 'x'*M*N)])
3676 def test_header_parser(self):
3677 eq = self.assertEqual
3684 self.assertFalse(msg.is_multipart())
3685 self.assertIsInstance(msg.get_payload(), str)
3687 def test_bytes_header_parser(self):
3688 eq = self.assertEqual
3695 self.assertFalse(msg.is_multipart())
3696 self.assertIsInstance(msg.get_payload(), str)
3697 self.assertIsInstance(msg.get_payload(decode=True), bytes)
3699 def test_bytes_parser_does_not_close_file(self):
3702 self.assertFalse(fp.closed)
3704 def test_bytes_parser_on_exception_does_not_close_file(self):
3707 self.assertRaises(email.errors.StartBoundaryNotFoundDefect,
3710 self.assertFalse(fp.closed)
3712 def test_parser_does_not_close_file(self):
3715 self.assertFalse(fp.closed)
3717 def test_parser_on_exception_does_not_close_file(self):
3720 self.assertRaises(email.errors.StartBoundaryNotFoundDefect,
3722 self.assertFalse(fp.closed)
3724 def test_whitespace_continuation(self):
3725 eq = self.assertEqual
3742 def test_whitespace_continuation_last_header(self):
3743 eq = self.assertEqual
3760 def test_crlf_separation(self):
3761 eq = self.assertEqual
3771 def test_crlf_flatten(self):
3779 self.assertEqual(s.getvalue(), text)
3783 def test_multipart_digest_with_extra_mime_headers(self):
3784 eq = self.assertEqual
3785 neq = self.ndiffAssertEqual
3814 def test_three_lines(self):
3820 self.assertEqual(msg['date'], 'Tue, 20 Aug 2002 16:43:45 +1000')
3822 def test_strip_line_feed_and_carriage_return_in_headers(self):
3823 eq = self.assertEqual
3833 def test_rfc2822_header_syntax(self):
3834 eq = self.assertEqual
3841 def test_rfc2822_space_not_allowed_in_header(self):
3842 eq = self.assertEqual
3847 def test_rfc2822_one_character_header(self):
3848 eq = self.assertEqual
3856 def test_CRLFLF_at_end_of_part(self):
3873 self.assertTrue(msg.get_payload(0).get_payload().endswith('\r\n'))
3895 def test_known_8bit_CTE(self):
3896 m = self.bodytest_msg.format(charset='utf-8',
3900 self.assertEqual(msg.get_payload(), "pöstal\n")
3901 self.assertEqual(msg.get_payload(decode=True),
3904 def test_unknown_8bit_CTE(self):
3905 m = self.bodytest_msg.format(charset='notavalidcharset',
3909 self.assertEqual(msg.get_payload(), "p\uFFFD\uFFFDstal\n")
3910 self.assertEqual(msg.get_payload(decode=True),
3913 def test_8bit_in_quopri_body(self):
3923 m = self.bodytest_msg.format(charset='utf-8',
3927 self.assertEqual(msg.get_payload(), 'p=C3=B6stál\n')
3928 self.assertEqual(msg.get_payload(decode=True),
3931 def test_invalid_8bit_in_non_8bit_cte_uses_replace(self):
3938 m = self.bodytest_msg.format(charset='ascii',
3942 self.assertEqual(msg.get_payload(), 'p=C3=B6st\uFFFD\uFFFDl\n')
3943 self.assertEqual(msg.get_payload(decode=True),
3947 def test_8bit_in_base64_body(self):
3951 m = self.bodytest_msg.format(charset='utf-8',
3955 self.assertEqual(msg.get_payload(decode=True),
3957 self.assertIsInstance(msg.defects[0],
3960 def test_8bit_in_uuencode_body(self):
3963 m = self.bodytest_msg.format(charset='utf-8',
3967 self.assertEqual(msg.get_payload(decode=True),
3984 def test_get_8bit_header(self):
3985 msg = email.message_from_bytes(self.headertest_msg)
3986 self.assertEqual(str(msg.get('to')), 'b\uFFFD\uFFFDz')
3987 self.assertEqual(str(msg['to']), 'b\uFFFD\uFFFDz')
3989 def test_print_8bit_headers(self):
3990 msg = email.message_from_bytes(self.headertest_msg)
3991 self.assertEqual(str(msg),
4000 self.headertest_headers]))
4002 def test_values_with_8bit_headers(self):
4003 msg = email.message_from_bytes(self.headertest_msg)
4004 self.assertListEqual([str(x) for x in msg.values()],
4013 def test_items_with_8bit_headers(self):
4014 msg = email.message_from_bytes(self.headertest_msg)
4015 self.assertListEqual([(str(x), str(y)) for (x, y) in msg.items()],
4025 def test_get_all_with_8bit_headers(self):
4026 msg = email.message_from_bytes(self.headertest_msg)
4027 self.assertListEqual([str(x) for x in msg.get_all('from')],
4031 def test_get_content_type_with_8bit(self):
4035 self.assertEqual(msg.get_content_type(), "text/pl\uFFFDin")
4036 self.assertEqual(msg.get_content_maintype(), "text")
4037 self.assertEqual(msg.get_content_subtype(), "pl\uFFFDin")
4040 def test_get_params_with_8bit(self):
4043 self.assertEqual(msg.get_params(header='x-header'),
4045 self.assertEqual(msg.get_param('Foo', header='x-header'), '\uFFFdne')
4047 self.assertEqual(msg.get_param('b\xa7r', header='x-header'), None)
4050 def test_get_rfc2231_params_with_8bit(self):
4055 self.assertEqual(msg.get_param('title'),
4058 def test_set_rfc2231_params_with_8bit(self):
4064 self.assertEqual(msg.get_param('title'), 'test')
4066 def test_del_rfc2231_params_with_8bit(self):
4072 self.assertEqual(msg.get_param('title'), None)
4073 self.assertEqual(msg.get_content_maintype(), 'text')
4075 def test_get_payload_with_8bit_cte_header(self):
4082 self.assertEqual(msg.get_payload(), 'payload\n')
4083 self.assertEqual(msg.get_payload(decode=True), b'payload\n')
4097 def test_bytes_generator(self):
4098 msg = email.message_from_bytes(self.non_latin_bin_msg)
4101 self.assertEqual(out.getvalue(), self.non_latin_bin_msg)
4103 def test_bytes_generator_handles_None_body(self):
4108 self.assertEqual(out.getvalue(), b"\n")
4123 def test_generator_handles_8bit(self):
4124 msg = email.message_from_bytes(self.non_latin_bin_msg)
4127 self.assertEqual(out.getvalue(), self.non_latin_bin_msg_as7bit_wrapped)
4129 def test_str_generator_should_not_mutate_msg_when_handling_8bit(self):
4130 msg = email.message_from_bytes(self.non_latin_bin_msg)
4137 self.assertEqual(out.getvalue(), orig_value)
4139 def test_bytes_generator_with_unix_from(self):
4143 msg = email.message_from_bytes(self.non_latin_bin_msg)
4147 self.assertEqual(lines[0].split()[0], b'From')
4148 self.assertEqual(b'\n'.join(lines[1:]), self.non_latin_bin_msg)
4156 def test_message_from_binary_file(self):
4158 self.addCleanup(unlink, fn)
4160 testfile.write(self.non_latin_bin_msg)
4163 self.assertEqual(str(m), self.non_latin_bin_msg_as7bit)
4187 def test_string_generator_reencodes_to_quopri_when_appropriate(self):
4188 m = email.message_from_bytes(self.latin_bin_msg)
4189 self.assertEqual(str(m), self.latin_bin_msg_as7bit)
4191 def test_decoded_generator_emits_unicode_body(self):
4192 m = email.message_from_bytes(self.latin_bin_msg)
4198 self.assertEqual(out.getvalue(),
4199 self.latin_bin_msg.decode('latin-1')+'\n')
4201 def test_bytes_feedparser(self):
4203 for i in range(0, len(self.latin_bin_msg), 10):
4204 bfp.feed(self.latin_bin_msg[i:i+10])
4206 self.assertEqual(str(m), self.latin_bin_msg_as7bit)
4208 def test_crlf_flatten(self):
4215 self.assertEqual(s.getvalue(), text)
4217 def test_8bit_multipart(self):
4261 self.assertEqual(s.getvalue(), source)
4263 def test_bytes_generator_b_encoding_linesep(self):
4271 self.assertEqual(
4275 def test_generator_b_encoding_linesep(self):
4283 self.assertEqual(
4294 def _msgobj(self, filename):
4297 data = self.normalize_linesep_regex.sub(self.blinesep, data)
4301 def _idempotent(self, msg, data, unixfrom=False):
4304 g.flatten(msg, unixfrom=unixfrom, linesep=self.linesep)
4305 self.assertEqual(data, b.getvalue())
4323 def test_len(self):
4324 eq = self.assertEqual
4336 def test_decode(self):
4337 eq = self.assertEqual
4341 def test_encode(self):
4342 eq = self.assertEqual
4363 def test_header_encode(self):
4364 eq = self.assertEqual
4375 def setUp(self):
4378 self.hlit = list(chain(
4385 self.hnon = [c for c in range(256) if c not in self.hlit]
4386 assert len(self.hlit) + len(self.hnon) == 256
4389 self.blit = list(range(ord(' '), ord('~') + 1))
4390 self.blit.append(ord('\t'))
4391 self.blit.remove(ord('='))
4394 self.bnon = [c for c in range(256) if c not in self.blit]
4395 assert len(self.blit) + len(self.bnon) == 256
4397 def test_quopri_header_check(self):
4398 for c in self.hlit:
4399 self.assertFalse(quoprimime.header_check(c),
4401 for c in self.hnon:
4402 self.assertTrue(quoprimime.header_check(c),
4405 def test_quopri_body_check(self):
4406 for c in self.blit:
4407 self.assertFalse(quoprimime.body_check(c),
4409 for c in self.bnon:
4410 self.assertTrue(quoprimime.body_check(c),
4413 def test_header_quopri_len(self):
4414 eq = self.assertEqual
4427 for c in self.hlit:
4430 for c in self.hnon:
4438 def test_body_quopri_len(self):
4439 eq = self.assertEqual
4440 for c in self.blit:
4442 for c in self.bnon:
4445 def test_quote_unquote_idempotent(self):
4448 self.assertEqual(quoprimime.unquote(quoprimime.quote(c)), c)
4450 def _test_header_encode(self, header, expected_encoded_header, charset=None):
4455 self.assertEqual(encoded_header, expected_encoded_header)
4457 def test_header_encode_null(self):
4458 self._test_header_encode(b'', '')
4460 def test_header_encode_one_word(self):
4461 self._test_header_encode(b'hello', '=?iso-8859-1?q?hello?=')
4463 def test_header_encode_two_lines(self):
4464 self._test_header_encode(b'hello\nworld',
4467 def test_header_encode_non_ascii(self):
4468 self._test_header_encode(b'hello\xc7there',
4471 def test_header_encode_alt_charset(self):
4472 self._test_header_encode(b'hello', '=?iso-8859-2?q?hello?=',
4475 def _test_header_decode(self, encoded_header, expected_decoded_header):
4477 self.assertEqual(decoded_header, expected_decoded_header)
4479 def test_header_decode_null(self):
4480 self._test_header_decode('', '')
4482 def test_header_decode_one_word(self):
4483 self._test_header_decode('hello', 'hello')
4485 def test_header_decode_two_lines(self):
4486 self._test_header_decode('hello=0Aworld', 'hello\nworld')
4488 def test_header_decode_non_ascii(self):
4489 self._test_header_decode('hello=C7there', 'hello\xc7there')
4491 def test_header_decode_re_bug_18380(self):
4493 self.assertEqual(quoprimime.header_decode('=30' * 257), '0' * 257)
4495 def _test_decode(self, encoded, expected_decoded, eol=None):
4500 self.assertEqual(decoded, expected_decoded)
4502 def test_decode_null_word(self):
4503 self._test_decode('', '')
4505 def test_decode_null_line_null_word(self):
4506 self._test_decode('\r\n', '\n')
4508 def test_decode_one_word(self):
4509 self._test_decode('hello', 'hello')
4511 def test_decode_one_word_eol(self):
4512 self._test_decode('hello', 'hello', eol='X')
4514 def test_decode_one_line(self):
4515 self._test_decode('hello\r\n', 'hello\n')
4517 def test_decode_one_line_lf(self):
4518 self._test_decode('hello\n', 'hello\n')
4520 def test_decode_one_line_cr(self):
4521 self._test_decode('hello\r', 'hello\n')
4523 def test_decode_one_line_nl(self):
4524 self._test_decode('hello\n', 'helloX', eol='X')
4526 def test_decode_one_line_crnl(self):
4527 self._test_decode('hello\r\n', 'helloX', eol='X')
4529 def test_decode_one_line_one_word(self):
4530 self._test_decode('hello\r\nworld', 'hello\nworld')
4532 def test_decode_one_line_one_word_eol(self):
4533 self._test_decode('hello\r\nworld', 'helloXworld', eol='X')
4535 def test_decode_two_lines(self):
4536 self._test_decode('hello\r\nworld\r\n', 'hello\nworld\n')
4538 def test_decode_two_lines_eol(self):
4539 self._test_decode('hello\r\nworld\r\n', 'helloXworldX', eol='X')
4541 def test_decode_one_long_line(self):
4542 self._test_decode('Spam' * 250, 'Spam' * 250)
4544 def test_decode_one_space(self):
4545 self._test_decode(' ', '')
4547 def test_decode_multiple_spaces(self):
4548 self._test_decode(' ' * 5, '')
4550 def test_decode_one_line_trailing_spaces(self):
4551 self._test_decode('hello \r\n', 'hello\n')
4553 def test_decode_two_lines_trailing_spaces(self):
4554 self._test_decode('hello \r\nworld \r\n', 'hello\nworld\n')
4556 def test_decode_quoted_word(self):
4557 self._test_decode('=22quoted=20words=22', '"quoted words"')
4559 def test_decode_uppercase_quoting(self):
4560 self._test_decode('ab=CD=EF', 'ab\xcd\xef')
4562 def test_decode_lowercase_quoting(self):
4563 self._test_decode('ab=cd=ef', 'ab\xcd\xef')
4565 def test_decode_soft_line_break(self):
4566 self._test_decode('soft line=\r\nbreak', 'soft linebreak')
4568 def test_decode_false_quoting(self):
4569 self._test_decode('A=1,B=A ==> A+B==2', 'A=1,B=A ==> A+B==2')
4571 def _test_encode(self, body, expected_encoded_body, maxlinelen=None, eol=None):
4584 self.assertEqual(encoded_body, expected_encoded_body)
4589 self.assertLessEqual(len(line), maxlinelen)
4591 def test_encode_null(self):
4592 self._test_encode('', '')
4594 def test_encode_null_lines(self):
4595 self._test_encode('\n\n', '\n\n')
4597 def test_encode_one_line(self):
4598 self._test_encode('hello\n', 'hello\n')
4600 def test_encode_one_line_crlf(self):
4601 self._test_encode('hello\r\n', 'hello\n')
4603 def test_encode_one_line_eol(self):
4604 self._test_encode('hello\n', 'hello\r\n', eol='\r\n')
4606 def test_encode_one_line_eol_after_non_ascii(self):
4608 self._test_encode('hello\u03c5\n'.encode('utf-8').decode('latin1'),
4611 def test_encode_one_space(self):
4612 self._test_encode(' ', '=20')
4614 def test_encode_one_line_one_space(self):
4615 self._test_encode(' \n', '=20\n')
4622 def test_encode_two_lines_one_space(self):
4623 self._test_encode(' \n \n', '=20\n=20\n')
4625 def test_encode_one_word_trailing_spaces(self):
4626 self._test_encode('hello ', 'hello =20')
4628 def test_encode_one_line_trailing_spaces(self):
4629 self._test_encode('hello \n', 'hello =20\n')
4631 def test_encode_one_word_trailing_tab(self):
4632 self._test_encode('hello \t', 'hello =09')
4634 def test_encode_one_line_trailing_tab(self):
4635 self._test_encode('hello \t\n', 'hello =09\n')
4637 def test_encode_trailing_space_before_maxlinelen(self):
4638 self._test_encode('abcd \n1234', 'abcd =\n\n1234', maxlinelen=6)
4640 def test_encode_trailing_space_at_maxlinelen(self):
4641 self._test_encode('abcd \n1234', 'abcd=\n=20\n1234', maxlinelen=5)
4643 def test_encode_trailing_space_beyond_maxlinelen(self):
4644 self._test_encode('abcd \n1234', 'abc=\nd=20\n1234', maxlinelen=4)
4646 def test_encode_whitespace_lines(self):
4647 self._test_encode(' \n' * 5, '=20\n' * 5)
4649 def test_encode_quoted_equals(self):
4650 self._test_encode('a = b', 'a =3D b')
4652 def test_encode_one_long_string(self):
4653 self._test_encode('x' * 100, 'x' * 75 + '=\n' + 'x' * 25)
4655 def test_encode_one_long_line(self):
4656 self._test_encode('x' * 100 + '\n', 'x' * 75 + '=\n' + 'x' * 25 + '\n')
4658 def test_encode_one_very_long_line(self):
4659 self._test_encode('x' * 200 + '\n',
4662 def test_encode_shortest_maxlinelen(self):
4663 self._test_encode('=' * 5, '=3D=\n' * 4 + '=3D', maxlinelen=4)
4665 def test_encode_maxlinelen_too_small(self):
4666 self.assertRaises(ValueError, self._test_encode, '', '', maxlinelen=3)
4668 def test_encode(self):
4669 eq = self.assertEqual
4697 def tearDown(self):
4704 def test_codec_encodeable(self):
4705 eq = self.assertEqual
4711 self.assertRaises(UnicodeError, c.header_encode, s)
4715 def test_body_encode(self):
4716 eq = self.assertEqual
4746 def test_unicode_charset_name(self):
4748 self.assertEqual(str(charset), 'us-ascii')
4749 self.assertRaises(errors.CharsetError, Charset, 'asc\xffii')
4755 def test_simple(self):
4756 eq = self.ndiffAssertEqual
4762 def test_simple_surprise(self):
4763 eq = self.ndiffAssertEqual
4769 def test_header_needs_no_decoding(self):
4771 self.assertEqual(decode_header(h), [(h, None)])
4773 def test_long(self):
4777 self.assertLessEqual(len(l), 76)
4779 def test_multilingual(self):
4780 eq = self.ndiffAssertEqual
4842 def test_empty_header_encode(self):
4844 self.assertEqual(h.encode(), '')
4846 def test_header_ctor_default_args(self):
4847 eq = self.ndiffAssertEqual
4853 def test_explicit_maxlinelen(self):
4854 eq = self.ndiffAssertEqual
4872 def test_quopri_splittable(self):
4873 eq = self.ndiffAssertEqual
4941 def test_base64_splittable(self):
4942 eq = self.ndiffAssertEqual
4995 def test_us_ascii_header(self):
4996 eq = self.assertEqual
5003 def test_string_charset(self):
5004 eq = self.assertEqual
5009 ## def test_unicode_error(self):
5010 ## raises = self.assertRaises
5018 def test_utf8_shortest(self):
5019 eq = self.assertEqual
5025 def test_bad_8bit_header(self):
5026 raises = self.assertRaises
5027 eq = self.assertEqual
5037 def test_escaped_8bit_header(self):
5041 self.assertEqual(str(h),
5043 self.assertEqual(email.header.decode_header(h), [(x, 'unknown-8bit')])
5045 def test_header_handles_binary_unknown8bit(self):
5048 self.assertEqual(str(h),
5050 self.assertEqual(email.header.decode_header(h), [(x, 'unknown-8bit')])
5052 def test_make_header_handles_binary_unknown8bit(self):
5056 self.assertEqual(str(h2),
5058 self.assertEqual(email.header.decode_header(h2), [(x, 'unknown-8bit')])
5060 def test_modify_returned_list_does_not_change_header(self):
5064 self.assertEqual(str(h), 'test')
5066 def test_encoded_adjacent_nonencoded(self):
5067 eq = self.assertEqual
5076 def test_whitespace_keeper(self):
5077 eq = self.assertEqual
5085 def test_broken_base64_header(self):
5086 raises = self.assertRaises
5090 def test_shift_jis_charset(self):
5092 self.assertEqual(h.encode(), '=?iso-2022-jp?b?GyRCSjgbKEI=?=')
5094 def test_flatten_header_with_no_value(self):
5099 self.assertEqual(str(msg), "EmptyHeader: \n\n")
5101 def test_encode_preserves_leading_ws_on_value(self):
5104 self.assertEqual(str(msg), "SomeHeader: value with leading ws\n\n")
5106 def test_whitespace_header(self):
5107 self.assertEqual(Header(' ').encode(), ' ')
5116 def test_get_param(self):
5117 eq = self.assertEqual
5118 msg = self._msgobj('msg_29.txt')
5124 def test_set_param(self):
5125 eq = self.ndiffAssertEqual
5135 msg = self._msgobj('msg_01.txt')
5161 def test_set_param_requote(self):
5164 self.assertEqual(msg['content-type'], 'text/plain; title="foo"')
5166 self.assertEqual(msg['content-type'], 'text/plain; title=bar')
5169 self.assertEqual(msg['content-type'], 'text/plain; title="(bar)bell"')
5171 def test_del_param(self):
5172 eq = self.ndiffAssertEqual
5173 msg = self._msgobj('msg_01.txt')
5204 def test_rfc2231_get_content_charset(self):
5205 eq = self.assertEqual
5206 msg = self._msgobj('msg_32.txt')
5210 def test_rfc2231_parse_rfc_quoting(self):
5219 self.assertEqual(msg.get_filename(),
5221 self.assertEqual(m, msg.as_string())
5224 def test_rfc2231_parse_extra_quoting(self):
5233 self.assertEqual(msg.get_filename(),
5235 self.assertEqual(m, msg.as_string())
5240 def test_rfc2231_no_language_or_charset(self):
5249 self.assertNotIsInstance(param, tuple)
5250 self.assertEqual(
5255 def test_rfc2231_no_language_or_charset_in_filename(self):
5264 self.assertEqual(msg.get_filename(),
5268 def test_rfc2231_no_language_or_charset_in_filename_encoded(self):
5277 self.assertEqual(msg.get_filename(),
5282 def test_rfc2231_partly_encoded(self):
5291 self.assertEqual(
5295 def test_rfc2231_partly_nonencoded(self):
5304 self.assertEqual(
5308 def test_rfc2231_no_language_or_charset_in_boundary(self):
5317 self.assertEqual(msg.get_boundary(),
5320 def test_rfc2231_no_language_or_charset_in_charset(self):
5330 self.assertEqual(msg.get_content_charset(),
5334 def test_rfc2231_bad_encoding_in_filename(self):
5343 self.assertEqual(msg.get_filename(),
5346 def test_rfc2231_bad_encoding_in_charset(self):
5354 self.assertEqual(msg.get_content_charset(), None)
5356 def test_rfc2231_bad_character_in_charset(self):
5364 self.assertEqual(msg.get_content_charset(), None)
5366 def test_rfc2231_bad_character_in_filename(self):
5375 self.assertEqual(msg.get_filename(),
5378 def test_rfc2231_unknown_encoding(self):
5385 self.assertEqual(msg.get_filename(), 'myfile.txt')
5387 def test_rfc2231_bad_character_in_encoding(self):
5394 self.assertEqual(msg.get_filename(), 'myfile.txt')
5396 def test_rfc2231_single_tick_in_filename_extended(self):
5397 eq = self.assertEqual
5410 def test_rfc2231_single_tick_in_filename(self):
5417 self.assertNotIsInstance(param, tuple)
5418 self.assertEqual(param, "Frank's Document")
5420 def test_rfc2231_missing_tick(self):
5426 self.assertEqual(
5430 def test_rfc2231_missing_tick_with_encoded_non_ascii(self):
5436 self.assertEqual(
5441 def test_rfc2231_tick_attack_extended(self):
5442 eq = self.assertEqual
5455 def test_rfc2231_tick_attack(self):
5463 self.assertNotIsInstance(param, tuple)
5464 self.assertEqual(param, "us-ascii'en-us'Frank's Document")
5467 def test_rfc2231_no_extended_values(self):
5468 eq = self.assertEqual
5477 def test_rfc2231_encoded_then_unencoded_segments(self):
5478 eq = self.assertEqual
5494 def test_rfc2231_unencoded_then_encoded_segments(self):
5495 eq = self.assertEqual
5509 def test_should_not_hang_on_invalid_ew_messages(self):
5528 with self.subTest(m=m):
5537 def _msg_and_obj(self, filename):
5543 def _signed_parts_eq(self, original, result):
5549 self.assertEqual(outpart, inpart)
5551 def test_long_headers_as_string(self):
5552 original, msg = self._msg_and_obj('msg_45.txt')
5554 self._signed_parts_eq(original, result)
5556 def test_long_headers_as_string_maxheaderlen(self):
5557 original, msg = self._msg_and_obj('msg_45.txt')
5559 self._signed_parts_eq(original, result)
5561 def test_long_headers_flatten(self):
5562 original, msg = self._msg_and_obj('msg_45.txt')
5566 self._signed_parts_eq(original, result)
5570 def test_HeaderRegistry(self):
5573 self.assertIsInstance(a.defects[0], errors.InvalidHeaderDefect)