Debian Codegraph @

Lib/test/test_email/test__header_value_parser.py

raw
1 import string
2 import unittest
3 from email import _header_value_parser as parser
4 from email import errors
5 from email import policy
6 from test.test_email import TestEmailBase, parameterize
7
8 class TestTokens(TestEmailBase):
9
10 # EWWhiteSpaceTerminal
11
12 def test_EWWhiteSpaceTerminal(self):
13 x = parser.EWWhiteSpaceTerminal(' \t', 'fws')
14 self.assertEqual(x, ' \t')
15 self.assertEqual(str(x), '')
16 self.assertEqual(x.value, '')
17 self.assertEqual(x.token_type, 'fws')
18
19
20 class TestParserMixin:
21
22 def _assert_results(self, tl, rest, string, value, defects, remainder,
23 comments=None):
24 self.assertEqual(str(tl), string)
25 self.assertEqual(tl.value, value)
26 self.assertDefectsEqual(tl.all_defects, defects)
27 self.assertEqual(rest, remainder)
28 if comments is not None:
29 self.assertEqual(tl.comments, comments)
30
31 def _test_get_x(self, method, source, string, value, defects,
32 remainder, comments=None):
33 tl, rest = method(source)
34 self._assert_results(tl, rest, string, value, defects, remainder,
35 comments=None)
36 return tl
37
38 def _test_parse_x(self, method, input, string, value, defects,
39 comments=None):
40 tl = method(input)
41 self._assert_results(tl, '', string, value, defects, '', comments)
42 return tl
43
44
45 class TestParser(TestParserMixin, TestEmailBase):
46
47 # _wsp_splitter
48
49 rfc_printable_ascii = bytes(range(33, 127)).decode('ascii')
50 rfc_atext_chars = (string.ascii_letters + string.digits +
51 "!#$%&\'*+-/=?^_`{}|~")
52 rfc_dtext_chars = rfc_printable_ascii.translate(str.maketrans('','',r'\[]'))
53
54 def test__wsp_splitter_one_word(self):
55 self.assertEqual(parser._wsp_splitter('foo', 1), ['foo'])
56
57 def test__wsp_splitter_two_words(self):
58 self.assertEqual(parser._wsp_splitter('foo def', 1),
59 ['foo', ' ', 'def'])
60
61 def test__wsp_splitter_ws_runs(self):
62 self.assertEqual(parser._wsp_splitter('foo \t def jik', 1),
63 ['foo', ' \t ', 'def jik'])
64
65
66 # get_fws
67
68 def test_get_fws_only(self):
69 fws = self._test_get_x(parser.get_fws, ' \t ', ' \t ', ' ', [], '')
70 self.assertEqual(fws.token_type, 'fws')
71
72 def test_get_fws_space(self):
73 self._test_get_x(parser.get_fws, ' foo', ' ', ' ', [], 'foo')
74
75 def test_get_fws_ws_run(self):
76 self._test_get_x(parser.get_fws, ' \t foo ', ' \t ', ' ', [], 'foo ')
77
78 # get_encoded_word
79
80 def test_get_encoded_word_missing_start_raises(self):
81 with self.assertRaises(errors.HeaderParseError):
82 parser.get_encoded_word('abc')
83
84 def test_get_encoded_word_missing_end_raises(self):
85 with self.assertRaises(errors.HeaderParseError):
86 parser.get_encoded_word('=?abc')
87
88 def test_get_encoded_word_missing_middle_raises(self):
89 with self.assertRaises(errors.HeaderParseError):
90 parser.get_encoded_word('=?abc?=')
91
92 def test_get_encoded_word_invalid_cte(self):
93 with self.assertRaises(errors.HeaderParseError):
94 parser.get_encoded_word('=?utf-8?X?somevalue?=')
95
96 def test_get_encoded_word_valid_ew(self):
97 self._test_get_x(parser.get_encoded_word,
98 '=?us-ascii?q?this_is_a_test?= bird',
99 'this is a test',
100 'this is a test',
101 [],
102 ' bird')
103
104 def test_get_encoded_word_internal_spaces(self):
105 self._test_get_x(parser.get_encoded_word,
106 '=?us-ascii?q?this is a test?= bird',
107 'this is a test',
108 'this is a test',
109 [errors.InvalidHeaderDefect],
110 ' bird')
111
112 def test_get_encoded_word_gets_first(self):
113 self._test_get_x(parser.get_encoded_word,
114 '=?us-ascii?q?first?= =?utf-8?q?second?=',
115 'first',
116 'first',
117 [],
118 ' =?utf-8?q?second?=')
119
120 def test_get_encoded_word_gets_first_even_if_no_space(self):
121 self._test_get_x(parser.get_encoded_word,
122 '=?us-ascii?q?first?==?utf-8?q?second?=',
123 'first',
124 'first',
125 [errors.InvalidHeaderDefect],
126 '=?utf-8?q?second?=')
127
128 def test_get_encoded_word_sets_extra_attributes(self):
129 ew = self._test_get_x(parser.get_encoded_word,
130 '=?us-ascii*jive?q?first_second?=',
131 'first second',
132 'first second',
133 [],
134 '')
135 self.assertEqual(ew.charset, 'us-ascii')
136 self.assertEqual(ew.lang, 'jive')
137
138 def test_get_encoded_word_lang_default_is_blank(self):
139 ew = self._test_get_x(parser.get_encoded_word,
140 '=?us-ascii?q?first_second?=',
141 'first second',
142 'first second',
143 [],
144 '')
145 self.assertEqual(ew.charset, 'us-ascii')
146 self.assertEqual(ew.lang, '')
147
148 def test_get_encoded_word_non_printable_defect(self):
149 self._test_get_x(parser.get_encoded_word,
150 '=?us-ascii?q?first\x02second?=',
151 'first\x02second',
152 'first\x02second',
153 [errors.NonPrintableDefect],
154 '')
155
156 def test_get_encoded_word_leading_internal_space(self):
157 self._test_get_x(parser.get_encoded_word,
158 '=?us-ascii?q?=20foo?=',
159 ' foo',
160 ' foo',
161 [],
162 '')
163
164 def test_get_encoded_word_quopri_utf_escape_follows_cte(self):
165 # Issue 18044
166 self._test_get_x(parser.get_encoded_word,
167 '=?utf-8?q?=C3=89ric?=',
168 'Éric',
169 'Éric',
170 [],
171 '')
172
173 # get_unstructured
174
175 def _get_unst(self, value):
176 token = parser.get_unstructured(value)
177 return token, ''
178
179 def test_get_unstructured_null(self):
180 self._test_get_x(self._get_unst, '', '', '', [], '')
181
182 def test_get_unstructured_one_word(self):
183 self._test_get_x(self._get_unst, 'foo', 'foo', 'foo', [], '')
184
185 def test_get_unstructured_normal_phrase(self):
186 self._test_get_x(self._get_unst, 'foo bar bird',
187 'foo bar bird',
188 'foo bar bird',
189 [],
190 '')
191
192 def test_get_unstructured_normal_phrase_with_whitespace(self):
193 self._test_get_x(self._get_unst, 'foo \t bar bird',
194 'foo \t bar bird',
195 'foo bar bird',
196 [],
197 '')
198
199 def test_get_unstructured_leading_whitespace(self):
200 self._test_get_x(self._get_unst, ' foo bar',
201 ' foo bar',
202 ' foo bar',
203 [],
204 '')
205
206 def test_get_unstructured_trailing_whitespace(self):
207 self._test_get_x(self._get_unst, 'foo bar ',
208 'foo bar ',
209 'foo bar ',
210 [],
211 '')
212
213 def test_get_unstructured_leading_and_trailing_whitespace(self):
214 self._test_get_x(self._get_unst, ' foo bar ',
215 ' foo bar ',
216 ' foo bar ',
217 [],
218 '')
219
220 def test_get_unstructured_one_valid_ew_no_ws(self):
221 self._test_get_x(self._get_unst, '=?us-ascii?q?bar?=',
222 'bar',
223 'bar',
224 [],
225 '')
226
227 def test_get_unstructured_one_ew_trailing_ws(self):
228 self._test_get_x(self._get_unst, '=?us-ascii?q?bar?= ',
229 'bar ',
230 'bar ',
231 [],
232 '')
233
234 def test_get_unstructured_one_valid_ew_trailing_text(self):
235 self._test_get_x(self._get_unst, '=?us-ascii?q?bar?= bird',
236 'bar bird',
237 'bar bird',
238 [],
239 '')
240
241 def test_get_unstructured_phrase_with_ew_in_middle_of_text(self):
242 self._test_get_x(self._get_unst, 'foo =?us-ascii?q?bar?= bird',
243 'foo bar bird',
244 'foo bar bird',
245 [],
246 '')
247
248 def test_get_unstructured_phrase_with_two_ew(self):
249 self._test_get_x(self._get_unst,
250 'foo =?us-ascii?q?bar?= =?us-ascii?q?bird?=',
251 'foo barbird',
252 'foo barbird',
253 [],
254 '')
255
256 def test_get_unstructured_phrase_with_two_ew_trailing_ws(self):
257 self._test_get_x(self._get_unst,
258 'foo =?us-ascii?q?bar?= =?us-ascii?q?bird?= ',
259 'foo barbird ',
260 'foo barbird ',
261 [],
262 '')
263
264 def test_get_unstructured_phrase_with_ew_with_leading_ws(self):
265 self._test_get_x(self._get_unst,
266 ' =?us-ascii?q?bar?=',
267 ' bar',
268 ' bar',
269 [],
270 '')
271
272 def test_get_unstructured_phrase_with_two_ew_extra_ws(self):
273 self._test_get_x(self._get_unst,
274 'foo =?us-ascii?q?bar?= \t =?us-ascii?q?bird?=',
275 'foo barbird',
276 'foo barbird',
277 [],
278 '')
279
280 def test_get_unstructured_two_ew_extra_ws_trailing_text(self):
281 self._test_get_x(self._get_unst,
282 '=?us-ascii?q?test?= =?us-ascii?q?foo?= val',
283 'testfoo val',
284 'testfoo val',
285 [],
286 '')
287
288 def test_get_unstructured_ew_with_internal_ws(self):
289 self._test_get_x(self._get_unst,
290 '=?iso-8859-1?q?hello=20world?=',
291 'hello world',
292 'hello world',
293 [],
294 '')
295
296 def test_get_unstructured_ew_with_internal_leading_ws(self):
297 self._test_get_x(self._get_unst,
298 ' =?us-ascii?q?=20test?= =?us-ascii?q?=20foo?= val',
299 ' test foo val',
300 ' test foo val',
301 [],
302 '')
303
304 def test_get_unstructured_invalid_ew(self):
305 self._test_get_x(self._get_unst,
306 '=?test val',
307 '=?test val',
308 '=?test val',
309 [],
310 '')
311
312 def test_get_unstructured_undecodable_bytes(self):
313 self._test_get_x(self._get_unst,
314 b'test \xACfoo val'.decode('ascii', 'surrogateescape'),
315 'test \uDCACfoo val',
316 'test \uDCACfoo val',
317 [errors.UndecodableBytesDefect],
318 '')
319
320 def test_get_unstructured_undecodable_bytes_in_EW(self):
321 self._test_get_x(self._get_unst,
322 (b'=?us-ascii?q?=20test?= =?us-ascii?q?=20\xACfoo?='
323 b' val').decode('ascii', 'surrogateescape'),
324 ' test \uDCACfoo val',
325 ' test \uDCACfoo val',
326 [errors.UndecodableBytesDefect]*2,
327 '')
328
329 def test_get_unstructured_missing_base64_padding(self):
330 self._test_get_x(self._get_unst,
331 '=?utf-8?b?dmk?=',
332 'vi',
333 'vi',
334 [errors.InvalidBase64PaddingDefect],
335 '')
336
337 def test_get_unstructured_invalid_base64_character(self):
338 self._test_get_x(self._get_unst,
339 '=?utf-8?b?dm\x01k===?=',
340 'vi',
341 'vi',
342 [errors.InvalidBase64CharactersDefect],
343 '')
344
345 def test_get_unstructured_invalid_base64_character_and_bad_padding(self):
346 self._test_get_x(self._get_unst,
347 '=?utf-8?b?dm\x01k?=',
348 'vi',
349 'vi',
350 [errors.InvalidBase64CharactersDefect,
351 errors.InvalidBase64PaddingDefect],
352 '')
353
354 def test_get_unstructured_invalid_base64_length(self):
355 # bpo-27397: Return the encoded string since there's no way to decode.
356 self._test_get_x(self._get_unst,
357 '=?utf-8?b?abcde?=',
358 'abcde',
359 'abcde',
360 [errors.InvalidBase64LengthDefect],
361 '')
362
363 def test_get_unstructured_no_whitespace_between_ews(self):
364 self._test_get_x(self._get_unst,
365 '=?utf-8?q?foo?==?utf-8?q?bar?=',
366 'foobar',
367 'foobar',
368 [errors.InvalidHeaderDefect,
369 errors.InvalidHeaderDefect],
370 '')
371
372 def test_get_unstructured_ew_without_leading_whitespace(self):
373 self._test_get_x(
374 self._get_unst,
375 'nowhitespace=?utf-8?q?somevalue?=',
376 'nowhitespacesomevalue',
377 'nowhitespacesomevalue',
378 [errors.InvalidHeaderDefect],
379 '')
380
381 def test_get_unstructured_ew_without_trailing_whitespace(self):
382 self._test_get_x(
383 self._get_unst,
384 '=?utf-8?q?somevalue?=nowhitespace',
385 'somevaluenowhitespace',
386 'somevaluenowhitespace',
387 [errors.InvalidHeaderDefect],
388 '')
389
390 def test_get_unstructured_without_trailing_whitespace_hang_case(self):
391 self._test_get_x(self._get_unst,
392 '=?utf-8?q?somevalue?=aa',
393 'somevalueaa',
394 'somevalueaa',
395 [errors.InvalidHeaderDefect],
396 '')
397
398 def test_get_unstructured_invalid_ew2(self):
399 self._test_get_x(self._get_unst,
400 '=?utf-8?q?=somevalue?=',
401 '=?utf-8?q?=somevalue?=',
402 '=?utf-8?q?=somevalue?=',
403 [],
404 '')
405
406 def test_get_unstructured_invalid_ew_cte(self):
407 self._test_get_x(self._get_unst,
408 '=?utf-8?X?=somevalue?=',
409 '=?utf-8?X?=somevalue?=',
410 '=?utf-8?X?=somevalue?=',
411 [],
412 '')
413
414 # get_qp_ctext
415
416 def test_get_qp_ctext_only(self):
417 ptext = self._test_get_x(parser.get_qp_ctext,
418 'foobar', 'foobar', ' ', [], '')
419 self.assertEqual(ptext.token_type, 'ptext')
420
421 def test_get_qp_ctext_all_printables(self):
422 with_qp = self.rfc_printable_ascii.replace('\\', '\\\\')
423 with_qp = with_qp. replace('(', r'\(')
424 with_qp = with_qp.replace(')', r'\)')
425 ptext = self._test_get_x(parser.get_qp_ctext,
426 with_qp, self.rfc_printable_ascii, ' ', [], '')
427
428 def test_get_qp_ctext_two_words_gets_first(self):
429 self._test_get_x(parser.get_qp_ctext,
430 'foo de', 'foo', ' ', [], ' de')
431
432 def test_get_qp_ctext_following_wsp_preserved(self):
433 self._test_get_x(parser.get_qp_ctext,
434 'foo \t\tde', 'foo', ' ', [], ' \t\tde')
435
436 def test_get_qp_ctext_up_to_close_paren_only(self):
437 self._test_get_x(parser.get_qp_ctext,
438 'foo)', 'foo', ' ', [], ')')
439
440 def test_get_qp_ctext_wsp_before_close_paren_preserved(self):
441 self._test_get_x(parser.get_qp_ctext,
442 'foo )', 'foo', ' ', [], ' )')
443
444 def test_get_qp_ctext_close_paren_mid_word(self):
445 self._test_get_x(parser.get_qp_ctext,
446 'foo)bar', 'foo', ' ', [], ')bar')
447
448 def test_get_qp_ctext_up_to_open_paren_only(self):
449 self._test_get_x(parser.get_qp_ctext,
450 'foo(', 'foo', ' ', [], '(')
451
452 def test_get_qp_ctext_wsp_before_open_paren_preserved(self):
453 self._test_get_x(parser.get_qp_ctext,
454 'foo (', 'foo', ' ', [], ' (')
455
456 def test_get_qp_ctext_open_paren_mid_word(self):
457 self._test_get_x(parser.get_qp_ctext,
458 'foo(bar', 'foo', ' ', [], '(bar')
459
460 def test_get_qp_ctext_non_printables(self):
461 ptext = self._test_get_x(parser.get_qp_ctext,
462 'foo\x00bar)', 'foo\x00bar', ' ',
463 [errors.NonPrintableDefect], ')')
464 self.assertEqual(ptext.defects[0].non_printables[0], '\x00')
465
466 def test_get_qp_ctext_close_paren_only(self):
467 self._test_get_x(parser.get_qp_ctext,
468 ')', '', ' ', [], ')')
469
470 def test_get_qp_ctext_open_paren_only(self):
471 self._test_get_x(parser.get_qp_ctext,
472 '(', '', ' ', [], '(')
473
474 def test_get_qp_ctext_no_end_char(self):
475 self._test_get_x(parser.get_qp_ctext,
476 '', '', ' ', [], '')
477
478
479 # get_qcontent
480
481 def test_get_qcontent_only(self):
482 ptext = self._test_get_x(parser.get_qcontent,
483 'foobar', 'foobar', 'foobar', [], '')
484 self.assertEqual(ptext.token_type, 'ptext')
485
486 def test_get_qcontent_all_printables(self):
487 with_qp = self.rfc_printable_ascii.replace('\\', '\\\\')
488 with_qp = with_qp. replace('"', r'\"')
489 ptext = self._test_get_x(parser.get_qcontent, with_qp,
490 self.rfc_printable_ascii,
491 self.rfc_printable_ascii, [], '')
492
493 def test_get_qcontent_two_words_gets_first(self):
494 self._test_get_x(parser.get_qcontent,
495 'foo de', 'foo', 'foo', [], ' de')
496
497 def test_get_qcontent_following_wsp_preserved(self):
498 self._test_get_x(parser.get_qcontent,
499 'foo \t\tde', 'foo', 'foo', [], ' \t\tde')
500
501 def test_get_qcontent_up_to_dquote_only(self):
502 self._test_get_x(parser.get_qcontent,
503 'foo"', 'foo', 'foo', [], '"')
504
505 def test_get_qcontent_wsp_before_close_paren_preserved(self):
506 self._test_get_x(parser.get_qcontent,
507 'foo "', 'foo', 'foo', [], ' "')
508
509 def test_get_qcontent_close_paren_mid_word(self):
510 self._test_get_x(parser.get_qcontent,
511 'foo"bar', 'foo', 'foo', [], '"bar')
512
513 def test_get_qcontent_non_printables(self):
514 ptext = self._test_get_x(parser.get_qcontent,
515 'foo\x00fg"', 'foo\x00fg', 'foo\x00fg',
516 [errors.NonPrintableDefect], '"')
517 self.assertEqual(ptext.defects[0].non_printables[0], '\x00')
518
519 def test_get_qcontent_empty(self):
520 self._test_get_x(parser.get_qcontent,
521 '"', '', '', [], '"')
522
523 def test_get_qcontent_no_end_char(self):
524 self._test_get_x(parser.get_qcontent,
525 '', '', '', [], '')
526
527 # get_atext
528
529 def test_get_atext_only(self):
530 atext = self._test_get_x(parser.get_atext,
531 'foobar', 'foobar', 'foobar', [], '')
532 self.assertEqual(atext.token_type, 'atext')
533
534 def test_get_atext_all_atext(self):
535 atext = self._test_get_x(parser.get_atext, self.rfc_atext_chars,
536 self.rfc_atext_chars,
537 self.rfc_atext_chars, [], '')
538
539 def test_get_atext_two_words_gets_first(self):
540 self._test_get_x(parser.get_atext,
541 'foo bar', 'foo', 'foo', [], ' bar')
542
543 def test_get_atext_following_wsp_preserved(self):
544 self._test_get_x(parser.get_atext,
545 'foo \t\tbar', 'foo', 'foo', [], ' \t\tbar')
546
547 def test_get_atext_up_to_special(self):
548 self._test_get_x(parser.get_atext,
549 'foo@bar', 'foo', 'foo', [], '@bar')
550
551 def test_get_atext_non_printables(self):
552 atext = self._test_get_x(parser.get_atext,
553 'foo\x00bar(', 'foo\x00bar', 'foo\x00bar',
554 [errors.NonPrintableDefect], '(')
555 self.assertEqual(atext.defects[0].non_printables[0], '\x00')
556
557 # get_bare_quoted_string
558
559 def test_get_bare_quoted_string_only(self):
560 bqs = self._test_get_x(parser.get_bare_quoted_string,
561 '"foo"', '"foo"', 'foo', [], '')
562 self.assertEqual(bqs.token_type, 'bare-quoted-string')
563
564 def test_get_bare_quoted_string_must_start_with_dquote(self):
565 with self.assertRaises(errors.HeaderParseError):
566 parser.get_bare_quoted_string('foo"')
567 with self.assertRaises(errors.HeaderParseError):
568 parser.get_bare_quoted_string(' "foo"')
569
570 def test_get_bare_quoted_string_only_quotes(self):
571 self._test_get_x(parser.get_bare_quoted_string,
572 '""', '""', '', [], '')
573
574 def test_get_bare_quoted_string_missing_endquotes(self):
575 self._test_get_x(parser.get_bare_quoted_string,
576 '"', '""', '', [errors.InvalidHeaderDefect], '')
577
578 def test_get_bare_quoted_string_following_wsp_preserved(self):
579 self._test_get_x(parser.get_bare_quoted_string,
580 '"foo"\t bar', '"foo"', 'foo', [], '\t bar')
581
582 def test_get_bare_quoted_string_multiple_words(self):
583 self._test_get_x(parser.get_bare_quoted_string,
584 '"foo bar moo"', '"foo bar moo"', 'foo bar moo', [], '')
585
586 def test_get_bare_quoted_string_multiple_words_wsp_preserved(self):
587 self._test_get_x(parser.get_bare_quoted_string,
588 '" foo moo\t"', '" foo moo\t"', ' foo moo\t', [], '')
589
590 def test_get_bare_quoted_string_end_dquote_mid_word(self):
591 self._test_get_x(parser.get_bare_quoted_string,
592 '"foo"bar', '"foo"', 'foo', [], 'bar')
593
594 def test_get_bare_quoted_string_quoted_dquote(self):
595 self._test_get_x(parser.get_bare_quoted_string,
596 r'"foo\"in"a', r'"foo\"in"', 'foo"in', [], 'a')
597
598 def test_get_bare_quoted_string_non_printables(self):
599 self._test_get_x(parser.get_bare_quoted_string,
600 '"a\x01a"', '"a\x01a"', 'a\x01a',
601 [errors.NonPrintableDefect], '')
602
603 def test_get_bare_quoted_string_no_end_dquote(self):
604 self._test_get_x(parser.get_bare_quoted_string,
605 '"foo', '"foo"', 'foo',
606 [errors.InvalidHeaderDefect], '')
607 self._test_get_x(parser.get_bare_quoted_string,
608 '"foo ', '"foo "', 'foo ',
609 [errors.InvalidHeaderDefect], '')
610
611 def test_get_bare_quoted_string_empty_quotes(self):
612 self._test_get_x(parser.get_bare_quoted_string,
613 '""', '""', '', [], '')
614
615 # Issue 16983: apply postel's law to some bad encoding.
616 def test_encoded_word_inside_quotes(self):
617 self._test_get_x(parser.get_bare_quoted_string,
618 '"=?utf-8?Q?not_really_valid?="',
619 '"not really valid"',
620 'not really valid',
621 [errors.InvalidHeaderDefect,
622 errors.InvalidHeaderDefect],
623 '')
624
625 # get_comment
626
627 def test_get_comment_only(self):
628 comment = self._test_get_x(parser.get_comment,
629 '(comment)', '(comment)', ' ', [], '', ['comment'])
630 self.assertEqual(comment.token_type, 'comment')
631
632 def test_get_comment_must_start_with_paren(self):
633 with self.assertRaises(errors.HeaderParseError):
634 parser.get_comment('foo"')
635 with self.assertRaises(errors.HeaderParseError):
636 parser.get_comment(' (foo"')
637
638 def test_get_comment_following_wsp_preserved(self):
639 self._test_get_x(parser.get_comment,
640 '(comment) \t', '(comment)', ' ', [], ' \t', ['comment'])
641
642 def test_get_comment_multiple_words(self):
643 self._test_get_x(parser.get_comment,
644 '(foo bar) \t', '(foo bar)', ' ', [], ' \t', ['foo bar'])
645
646 def test_get_comment_multiple_words_wsp_preserved(self):
647 self._test_get_x(parser.get_comment,
648 '( foo bar\t ) \t', '( foo bar\t )', ' ', [], ' \t',
649 [' foo bar\t '])
650
651 def test_get_comment_end_paren_mid_word(self):
652 self._test_get_x(parser.get_comment,
653 '(foo)bar', '(foo)', ' ', [], 'bar', ['foo'])
654
655 def test_get_comment_quoted_parens(self):
656 self._test_get_x(parser.get_comment,
657 r'(foo\) \(\)bar)', r'(foo\) \(\)bar)', ' ', [], '', ['foo) ()bar'])
658
659 def test_get_comment_non_printable(self):
660 self._test_get_x(parser.get_comment,
661 '(foo\x7Fbar)', '(foo\x7Fbar)', ' ',
662 [errors.NonPrintableDefect], '', ['foo\x7Fbar'])
663
664 def test_get_comment_no_end_paren(self):
665 self._test_get_x(parser.get_comment,
666 '(foo bar', '(foo bar)', ' ',
667 [errors.InvalidHeaderDefect], '', ['foo bar'])
668 self._test_get_x(parser.get_comment,
669 '(foo bar ', '(foo bar )', ' ',
670 [errors.InvalidHeaderDefect], '', ['foo bar '])
671
672 def test_get_comment_nested_comment(self):
673 comment = self._test_get_x(parser.get_comment,
674 '(foo(bar))', '(foo(bar))', ' ', [], '', ['foo(bar)'])
675 self.assertEqual(comment[1].content, 'bar')
676
677 def test_get_comment_nested_comment_wsp(self):
678 comment = self._test_get_x(parser.get_comment,
679 '(foo ( bar ) )', '(foo ( bar ) )', ' ', [], '', ['foo ( bar ) '])
680 self.assertEqual(comment[2].content, ' bar ')
681
682 def test_get_comment_empty_comment(self):
683 self._test_get_x(parser.get_comment,
684 '()', '()', ' ', [], '', [''])
685
686 def test_get_comment_multiple_nesting(self):
687 comment = self._test_get_x(parser.get_comment,
688 '(((((foo)))))', '(((((foo)))))', ' ', [], '', ['((((foo))))'])
689 for i in range(4, 0, -1):
690 self.assertEqual(comment[0].content, '('*(i-1)+'foo'+')'*(i-1))
691 comment = comment[0]
692 self.assertEqual(comment.content, 'foo')
693
694 def test_get_comment_missing_end_of_nesting(self):
695 self._test_get_x(parser.get_comment,
696 '(((((foo)))', '(((((foo)))))', ' ',
697 [errors.InvalidHeaderDefect]*2, '', ['((((foo))))'])
698
699 def test_get_comment_qs_in_nested_comment(self):
700 comment = self._test_get_x(parser.get_comment,
701 r'(foo (b\)))', r'(foo (b\)))', ' ', [], '', [r'foo (b\))'])
702 self.assertEqual(comment[2].content, 'b)')
703
704 # get_cfws
705
706 def test_get_cfws_only_ws(self):
707 cfws = self._test_get_x(parser.get_cfws,
708 ' \t \t', ' \t \t', ' ', [], '', [])
709 self.assertEqual(cfws.token_type, 'cfws')
710
711 def test_get_cfws_only_comment(self):
712 cfws = self._test_get_x(parser.get_cfws,
713 '(foo)', '(foo)', ' ', [], '', ['foo'])
714 self.assertEqual(cfws[0].content, 'foo')
715
716 def test_get_cfws_only_mixed(self):
717 cfws = self._test_get_x(parser.get_cfws,
718 ' (foo ) ( bar) ', ' (foo ) ( bar) ', ' ', [], '',
719 ['foo ', ' bar'])
720 self.assertEqual(cfws[1].content, 'foo ')
721 self.assertEqual(cfws[3].content, ' bar')
722
723 def test_get_cfws_ends_at_non_leader(self):
724 cfws = self._test_get_x(parser.get_cfws,
725 '(foo) bar', '(foo) ', ' ', [], 'bar', ['foo'])
726 self.assertEqual(cfws[0].content, 'foo')
727
728 def test_get_cfws_ends_at_non_printable(self):
729 cfws = self._test_get_x(parser.get_cfws,
730 '(foo) \x07', '(foo) ', ' ', [], '\x07', ['foo'])
731 self.assertEqual(cfws[0].content, 'foo')
732
733 def test_get_cfws_non_printable_in_comment(self):
734 cfws = self._test_get_x(parser.get_cfws,
735 '(foo \x07) "test"', '(foo \x07) ', ' ',
736 [errors.NonPrintableDefect], '"test"', ['foo \x07'])
737 self.assertEqual(cfws[0].content, 'foo \x07')
738
739 def test_get_cfws_header_ends_in_comment(self):
740 cfws = self._test_get_x(parser.get_cfws,
741 ' (foo ', ' (foo )', ' ',
742 [errors.InvalidHeaderDefect], '', ['foo '])
743 self.assertEqual(cfws[1].content, 'foo ')
744
745 def test_get_cfws_multiple_nested_comments(self):
746 cfws = self._test_get_x(parser.get_cfws,
747 '(foo (bar)) ((a)(a))', '(foo (bar)) ((a)(a))', ' ', [],
748 '', ['foo (bar)', '(a)(a)'])
749 self.assertEqual(cfws[0].comments, ['foo (bar)'])
750 self.assertEqual(cfws[2].comments, ['(a)(a)'])
751
752 # get_quoted_string
753
754 def test_get_quoted_string_only(self):
755 qs = self._test_get_x(parser.get_quoted_string,
756 '"bob"', '"bob"', 'bob', [], '')
757 self.assertEqual(qs.token_type, 'quoted-string')
758 self.assertEqual(qs.quoted_value, '"bob"')
759 self.assertEqual(qs.content, 'bob')
760
761 def test_get_quoted_string_with_wsp(self):
762 qs = self._test_get_x(parser.get_quoted_string,
763 '\t "bob" ', '\t "bob" ', ' bob ', [], '')
764 self.assertEqual(qs.quoted_value, ' "bob" ')
765 self.assertEqual(qs.content, 'bob')
766
767 def test_get_quoted_string_with_comments_and_wsp(self):
768 qs = self._test_get_x(parser.get_quoted_string,
769 ' (foo) "bob"(bar)', ' (foo) "bob"(bar)', ' bob ', [], '')
770 self.assertEqual(qs[0][1].content, 'foo')
771 self.assertEqual(qs[2][0].content, 'bar')
772 self.assertEqual(qs.content, 'bob')
773 self.assertEqual(qs.quoted_value, ' "bob" ')
774
775 def test_get_quoted_string_with_multiple_comments(self):
776 qs = self._test_get_x(parser.get_quoted_string,
777 ' (foo) (bar) "bob"(bird)', ' (foo) (bar) "bob"(bird)', ' bob ',
778 [], '')
779 self.assertEqual(qs[0].comments, ['foo', 'bar'])
780 self.assertEqual(qs[2].comments, ['bird'])
781 self.assertEqual(qs.content, 'bob')
782 self.assertEqual(qs.quoted_value, ' "bob" ')
783
784 def test_get_quoted_string_non_printable_in_comment(self):
785 qs = self._test_get_x(parser.get_quoted_string,
786 ' (\x0A) "bob"', ' (\x0A) "bob"', ' bob',
787 [errors.NonPrintableDefect], '')
788 self.assertEqual(qs[0].comments, ['\x0A'])
789 self.assertEqual(qs.content, 'bob')
790 self.assertEqual(qs.quoted_value, ' "bob"')
791
792 def test_get_quoted_string_non_printable_in_qcontent(self):
793 qs = self._test_get_x(parser.get_quoted_string,
794 ' (a) "a\x0B"', ' (a) "a\x0B"', ' a\x0B',
795 [errors.NonPrintableDefect], '')
796 self.assertEqual(qs[0].comments, ['a'])
797 self.assertEqual(qs.content, 'a\x0B')
798 self.assertEqual(qs.quoted_value, ' "a\x0B"')
799
800 def test_get_quoted_string_internal_ws(self):
801 qs = self._test_get_x(parser.get_quoted_string,
802 ' (a) "foo bar "', ' (a) "foo bar "', ' foo bar ',
803 [], '')
804 self.assertEqual(qs[0].comments, ['a'])
805 self.assertEqual(qs.content, 'foo bar ')
806 self.assertEqual(qs.quoted_value, ' "foo bar "')
807
808 def test_get_quoted_string_header_ends_in_comment(self):
809 qs = self._test_get_x(parser.get_quoted_string,
810 ' (a) "bob" (a', ' (a) "bob" (a)', ' bob ',
811 [errors.InvalidHeaderDefect], '')
812 self.assertEqual(qs[0].comments, ['a'])
813 self.assertEqual(qs[2].comments, ['a'])
814 self.assertEqual(qs.content, 'bob')
815 self.assertEqual(qs.quoted_value, ' "bob" ')
816
817 def test_get_quoted_string_header_ends_in_qcontent(self):
818 qs = self._test_get_x(parser.get_quoted_string,
819 ' (a) "bob', ' (a) "bob"', ' bob',
820 [errors.InvalidHeaderDefect], '')
821 self.assertEqual(qs[0].comments, ['a'])
822 self.assertEqual(qs.content, 'bob')
823 self.assertEqual(qs.quoted_value, ' "bob"')
824
825 def test_get_quoted_string_cfws_only_raises(self):
826 with self.assertRaises(errors.HeaderParseError):
827 parser.get_quoted_string(' (foo) ')
828
829 def test_get_quoted_string_no_quoted_string(self):
830 with self.assertRaises(errors.HeaderParseError):
831 parser.get_quoted_string(' (ab) xyz')
832
833 def test_get_quoted_string_qs_ends_at_noncfws(self):
834 qs = self._test_get_x(parser.get_quoted_string,
835 '\t "bob" fee', '\t "bob" ', ' bob ', [], 'fee')
836 self.assertEqual(qs.content, 'bob')
837 self.assertEqual(qs.quoted_value, ' "bob" ')
838
839 # get_atom
840
841 def test_get_atom_only(self):
842 atom = self._test_get_x(parser.get_atom,
843 'bob', 'bob', 'bob', [], '')
844 self.assertEqual(atom.token_type, 'atom')
845
846 def test_get_atom_with_wsp(self):
847 self._test_get_x(parser.get_atom,
848 '\t bob ', '\t bob ', ' bob ', [], '')
849
850 def test_get_atom_with_comments_and_wsp(self):
851 atom = self._test_get_x(parser.get_atom,
852 ' (foo) bob(bar)', ' (foo) bob(bar)', ' bob ', [], '')
853 self.assertEqual(atom[0][1].content, 'foo')
854 self.assertEqual(atom[2][0].content, 'bar')
855
856 def test_get_atom_with_multiple_comments(self):
857 atom = self._test_get_x(parser.get_atom,
858 ' (foo) (bar) bob(bird)', ' (foo) (bar) bob(bird)', ' bob ',
859 [], '')
860 self.assertEqual(atom[0].comments, ['foo', 'bar'])
861 self.assertEqual(atom[2].comments, ['bird'])
862
863 def test_get_atom_non_printable_in_comment(self):
864 atom = self._test_get_x(parser.get_atom,
865 ' (\x0A) bob', ' (\x0A) bob', ' bob',
866 [errors.NonPrintableDefect], '')
867 self.assertEqual(atom[0].comments, ['\x0A'])
868
869 def test_get_atom_non_printable_in_atext(self):
870 atom = self._test_get_x(parser.get_atom,
871 ' (a) a\x0B', ' (a) a\x0B', ' a\x0B',
872 [errors.NonPrintableDefect], '')
873 self.assertEqual(atom[0].comments, ['a'])
874
875 def test_get_atom_header_ends_in_comment(self):
876 atom = self._test_get_x(parser.get_atom,
877 ' (a) bob (a', ' (a) bob (a)', ' bob ',
878 [errors.InvalidHeaderDefect], '')
879 self.assertEqual(atom[0].comments, ['a'])
880 self.assertEqual(atom[2].comments, ['a'])
881
882 def test_get_atom_no_atom(self):
883 with self.assertRaises(errors.HeaderParseError):
884 parser.get_atom(' (ab) ')
885
886 def test_get_atom_no_atom_before_special(self):
887 with self.assertRaises(errors.HeaderParseError):
888 parser.get_atom(' (ab) @')
889
890 def test_get_atom_atom_ends_at_special(self):
891 atom = self._test_get_x(parser.get_atom,
892 ' (foo) bob(bar) @bang', ' (foo) bob(bar) ', ' bob ', [], '@bang')
893 self.assertEqual(atom[0].comments, ['foo'])
894 self.assertEqual(atom[2].comments, ['bar'])
895
896 def test_get_atom_atom_ends_at_noncfws(self):
897 self._test_get_x(parser.get_atom,
898 'bob fred', 'bob ', 'bob ', [], 'fred')
899
900 def test_get_atom_rfc2047_atom(self):
901 self._test_get_x(parser.get_atom,
902 '=?utf-8?q?=20bob?=', ' bob', ' bob', [], '')
903
904 # get_dot_atom_text
905
906 def test_get_dot_atom_text(self):
907 dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
908 'foo.bar.bang', 'foo.bar.bang', 'foo.bar.bang', [], '')
909 self.assertEqual(dot_atom_text.token_type, 'dot-atom-text')
910 self.assertEqual(len(dot_atom_text), 5)
911
912 def test_get_dot_atom_text_lone_atom_is_valid(self):
913 dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
914 'foo', 'foo', 'foo', [], '')
915
916 def test_get_dot_atom_text_raises_on_leading_dot(self):
917 with self.assertRaises(errors.HeaderParseError):
918 parser.get_dot_atom_text('.foo.bar')
919
920 def test_get_dot_atom_text_raises_on_trailing_dot(self):
921 with self.assertRaises(errors.HeaderParseError):
922 parser.get_dot_atom_text('foo.bar.')
923
924 def test_get_dot_atom_text_raises_on_leading_non_atext(self):
925 with self.assertRaises(errors.HeaderParseError):
926 parser.get_dot_atom_text(' foo.bar')
927 with self.assertRaises(errors.HeaderParseError):
928 parser.get_dot_atom_text('@foo.bar')
929 with self.assertRaises(errors.HeaderParseError):
930 parser.get_dot_atom_text('"foo.bar"')
931
932 def test_get_dot_atom_text_trailing_text_preserved(self):
933 dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
934 'foo@bar', 'foo', 'foo', [], '@bar')
935
936 def test_get_dot_atom_text_trailing_ws_preserved(self):
937 dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
938 'foo .bar', 'foo', 'foo', [], ' .bar')
939
940 # get_dot_atom
941
942 def test_get_dot_atom_only(self):
943 dot_atom = self._test_get_x(parser.get_dot_atom,
944 'foo.bar.bing', 'foo.bar.bing', 'foo.bar.bing', [], '')
945 self.assertEqual(dot_atom.token_type, 'dot-atom')
946 self.assertEqual(len(dot_atom), 1)
947
948 def test_get_dot_atom_with_wsp(self):
949 self._test_get_x(parser.get_dot_atom,
950 '\t foo.bar.bing ', '\t foo.bar.bing ', ' foo.bar.bing ', [], '')
951
952 def test_get_dot_atom_with_comments_and_wsp(self):
953 self._test_get_x(parser.get_dot_atom,
954 ' (sing) foo.bar.bing (here) ', ' (sing) foo.bar.bing (here) ',
955 ' foo.bar.bing ', [], '')
956
957 def test_get_dot_atom_space_ends_dot_atom(self):
958 self._test_get_x(parser.get_dot_atom,
959 ' (sing) foo.bar .bing (here) ', ' (sing) foo.bar ',
960 ' foo.bar ', [], '.bing (here) ')
961
962 def test_get_dot_atom_no_atom_raises(self):
963 with self.assertRaises(errors.HeaderParseError):
964 parser.get_dot_atom(' (foo) ')
965
966 def test_get_dot_atom_leading_dot_raises(self):
967 with self.assertRaises(errors.HeaderParseError):
968 parser.get_dot_atom(' (foo) .bar')
969
970 def test_get_dot_atom_two_dots_raises(self):
971 with self.assertRaises(errors.HeaderParseError):
972 parser.get_dot_atom('bar..bang')
973
974 def test_get_dot_atom_trailing_dot_raises(self):
975 with self.assertRaises(errors.HeaderParseError):
976 parser.get_dot_atom(' (foo) bar.bang. foo')
977
978 def test_get_dot_atom_rfc2047_atom(self):
979 self._test_get_x(parser.get_dot_atom,
980 '=?utf-8?q?=20bob?=', ' bob', ' bob', [], '')
981
982 # get_word (if this were black box we'd repeat all the qs/atom tests)
983
984 def test_get_word_atom_yields_atom(self):
985 word = self._test_get_x(parser.get_word,
986 ' (foo) bar (bang) :ah', ' (foo) bar (bang) ', ' bar ', [], ':ah')
987 self.assertEqual(word.token_type, 'atom')
988 self.assertEqual(word[0].token_type, 'cfws')
989
990 def test_get_word_all_CFWS(self):
991 # bpo-29412: Test that we don't raise IndexError when parsing CFWS only
992 # token.
993 with self.assertRaises(errors.HeaderParseError):
994 parser.get_word('(Recipients list suppressed')
995
996 def test_get_word_qs_yields_qs(self):
997 word = self._test_get_x(parser.get_word,
998 '"bar " (bang) ah', '"bar " (bang) ', 'bar ', [], 'ah')
999 self.assertEqual(word.token_type, 'quoted-string')
1000 self.assertEqual(word[0].token_type, 'bare-quoted-string')
1001 self.assertEqual(word[0].value, 'bar ')
1002 self.assertEqual(word.content, 'bar ')
1003
1004 def test_get_word_ends_at_dot(self):
1005 self._test_get_x(parser.get_word,
1006 'foo.', 'foo', 'foo', [], '.')
1007
1008 # get_phrase
1009
1010 def test_get_phrase_simple(self):
1011 phrase = self._test_get_x(parser.get_phrase,
1012 '"Fred A. Johnson" is his name, oh.',
1013 '"Fred A. Johnson" is his name',
1014 'Fred A. Johnson is his name',
1015 [],
1016 ', oh.')
1017 self.assertEqual(phrase.token_type, 'phrase')
1018
1019 def test_get_phrase_complex(self):
1020 phrase = self._test_get_x(parser.get_phrase,
1021 ' (A) bird (in (my|your)) "hand " is messy\t<>\t',
1022 ' (A) bird (in (my|your)) "hand " is messy\t',
1023 ' bird hand is messy ',
1024 [],
1025 '<>\t')
1026 self.assertEqual(phrase[0][0].comments, ['A'])
1027 self.assertEqual(phrase[0][2].comments, ['in (my|your)'])
1028
1029 def test_get_phrase_obsolete(self):
1030 phrase = self._test_get_x(parser.get_phrase,
1031 'Fred A.(weird).O Johnson',
1032 'Fred A.(weird).O Johnson',
1033 'Fred A. .O Johnson',
1034 [errors.ObsoleteHeaderDefect]*3,
1035 '')
1036 self.assertEqual(len(phrase), 7)
1037 self.assertEqual(phrase[3].comments, ['weird'])
1038
1039 def test_get_phrase_pharse_must_start_with_word(self):
1040 phrase = self._test_get_x(parser.get_phrase,
1041 '(even weirder).name',
1042 '(even weirder).name',
1043 ' .name',
1044 [errors.InvalidHeaderDefect] + [errors.ObsoleteHeaderDefect]*2,
1045 '')
1046 self.assertEqual(len(phrase), 3)
1047 self.assertEqual(phrase[0].comments, ['even weirder'])
1048
1049 def test_get_phrase_ending_with_obsolete(self):
1050 phrase = self._test_get_x(parser.get_phrase,
1051 'simple phrase.(with trailing comment):boo',
1052 'simple phrase.(with trailing comment)',
1053 'simple phrase. ',
1054 [errors.ObsoleteHeaderDefect]*2,
1055 ':boo')
1056 self.assertEqual(len(phrase), 4)
1057 self.assertEqual(phrase[3].comments, ['with trailing comment'])
1058
1059 def get_phrase_cfws_only_raises(self):
1060 with self.assertRaises(errors.HeaderParseError):
1061 parser.get_phrase(' (foo) ')
1062
1063 def test_get_phrase_adjacent_ew(self):
1064 # "'linear-white-space' that separates a pair of adjacent
1065 # 'encoded-word's is ignored" (rfc2047 section 6.2)
1066 self._test_get_x(parser.get_phrase, '=?ascii?q?Joi?= \t =?ascii?q?ned?=', 'Joined', 'Joined', [], '')
1067
1068 def test_get_phrase_adjacent_ew_different_encodings(self):
1069 self._test_get_x(
1070 parser.get_phrase,
1071 '=?utf-8?q?B=C3=A9r?= =?iso-8859-1?q?=E9nice?=', 'Bérénice', 'Bérénice', [], ''
1072 )
1073
1074 def test_get_phrase_adjacent_ew_encoded_spaces(self):
1075 self._test_get_x(
1076 parser.get_phrase,
1077 '=?ascii?q?Encoded?= =?ascii?q?_spaces_?= =?ascii?q?preserved?=',
1078 'Encoded spaces preserved',
1079 'Encoded spaces preserved',
1080 [],
1081 ''
1082 )
1083
1084 def test_get_phrase_adjacent_ew_comment_is_not_linear_white_space(self):
1085 self._test_get_x(
1086 parser.get_phrase,
1087 '=?ascii?q?Comment?= (is not) =?ascii?q?linear-white-space?=',
1088 'Comment (is not) linear-white-space',
1089 'Comment linear-white-space',
1090 [],
1091 '',
1092 comments=['is not'],
1093 )
1094
1095 def test_get_phrase_adjacent_ew_no_error_on_defects(self):
1096 self._test_get_x(
1097 parser.get_phrase,
1098 '=?ascii?q?Def?= =?ascii?q?ect still joins?=',
1099 'Defect still joins',
1100 'Defect still joins',
1101 [errors.InvalidHeaderDefect], # whitespace inside encoded word
1102 ''
1103 )
1104
1105 def test_get_phrase_adjacent_ew_ignore_non_ew(self):
1106 self._test_get_x(
1107 parser.get_phrase,
1108 '=?ascii?q?No?= =?join?= for non-ew',
1109 'No =?join?= for non-ew',
1110 'No =?join?= for non-ew',
1111 [],
1112 ''
1113 )
1114
1115 def test_get_phrase_adjacent_ew_ignore_invalid_ew(self):
1116 self._test_get_x(
1117 parser.get_phrase,
1118 '=?ascii?q?No?= =?ascii?rot13?wbva= for invalid ew',
1119 'No =?ascii?rot13?wbva= for invalid ew',
1120 'No =?ascii?rot13?wbva= for invalid ew',
1121 [],
1122 ''
1123 )
1124
1125 def test_get_phrase_adjacent_ew_missing_space(self):
1126 self._test_get_x(
1127 parser.get_phrase,
1128 '=?ascii?q?Joi?==?ascii?q?ned?=',
1129 'Joined',
1130 'Joined',
1131 [errors.InvalidHeaderDefect], # missing trailing whitespace
1132 ''
1133 )
1134
1135 # get_local_part
1136
1137 def test_get_local_part_simple(self):
1138 local_part = self._test_get_x(parser.get_local_part,
1139 '[email protected]', 'dinsdale', 'dinsdale', [], '@python.org')
1140 self.assertEqual(local_part.token_type, 'local-part')
1141 self.assertEqual(local_part.local_part, 'dinsdale')
1142
1143 def test_get_local_part_with_dot(self):
1144 local_part = self._test_get_x(parser.get_local_part,
1145 '[email protected]',
1146 'Fred.A.Johnson',
1147 'Fred.A.Johnson',
1148 [],
1149 '@python.org')
1150 self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
1151
1152 def test_get_local_part_with_whitespace(self):
1153 local_part = self._test_get_x(parser.get_local_part,
1154 ' Fred.A.Johnson @python.org',
1155 ' Fred.A.Johnson ',
1156 ' Fred.A.Johnson ',
1157 [],
1158 '@python.org')
1159 self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
1160
1161 def test_get_local_part_with_cfws(self):
1162 local_part = self._test_get_x(parser.get_local_part,
1163 ' (foo) Fred.A.Johnson (bar (bird)) @python.org',
1164 ' (foo) Fred.A.Johnson (bar (bird)) ',
1165 ' Fred.A.Johnson ',
1166 [],
1167 '@python.org')
1168 self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
1169 self.assertEqual(local_part[0][0].comments, ['foo'])
1170 self.assertEqual(local_part[0][2].comments, ['bar (bird)'])
1171
1172 def test_get_local_part_simple_quoted(self):
1173 local_part = self._test_get_x(parser.get_local_part,
1174 '"dinsdale"@python.org', '"dinsdale"', '"dinsdale"', [], '@python.org')
1175 self.assertEqual(local_part.token_type, 'local-part')
1176 self.assertEqual(local_part.local_part, 'dinsdale')
1177
1178 def test_get_local_part_with_quoted_dot(self):
1179 local_part = self._test_get_x(parser.get_local_part,
1180 '"Fred.A.Johnson"@python.org',
1181 '"Fred.A.Johnson"',
1182 '"Fred.A.Johnson"',
1183 [],
1184 '@python.org')
1185 self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
1186
1187 def test_get_local_part_quoted_with_whitespace(self):
1188 local_part = self._test_get_x(parser.get_local_part,
1189 ' "Fred A. Johnson" @python.org',
1190 ' "Fred A. Johnson" ',
1191 ' "Fred A. Johnson" ',
1192 [],
1193 '@python.org')
1194 self.assertEqual(local_part.local_part, 'Fred A. Johnson')
1195
1196 def test_get_local_part_quoted_with_cfws(self):
1197 local_part = self._test_get_x(parser.get_local_part,
1198 ' (foo) " Fred A. Johnson " (bar (bird)) @python.org',
1199 ' (foo) " Fred A. Johnson " (bar (bird)) ',
1200 ' " Fred A. Johnson " ',
1201 [],
1202 '@python.org')
1203 self.assertEqual(local_part.local_part, ' Fred A. Johnson ')
1204 self.assertEqual(local_part[0][0].comments, ['foo'])
1205 self.assertEqual(local_part[0][2].comments, ['bar (bird)'])
1206
1207
1208 def test_get_local_part_simple_obsolete(self):
1209 local_part = self._test_get_x(parser.get_local_part,
1210 'Fred. [email protected]',
1211 'Fred. A.Johnson',
1212 'Fred. A.Johnson',
1213 [errors.ObsoleteHeaderDefect],
1214 '@python.org')
1215 self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
1216
1217 def test_get_local_part_complex_obsolete_1(self):
1218 local_part = self._test_get_x(parser.get_local_part,
1219 ' (foo )Fred (bar).(bird) A.(sheep)Johnson."and dogs "@python.org',
1220 ' (foo )Fred (bar).(bird) A.(sheep)Johnson."and dogs "',
1221 ' Fred . A. Johnson.and dogs ',
1222 [errors.ObsoleteHeaderDefect],
1223 '@python.org')
1224 self.assertEqual(local_part.local_part, 'Fred.A.Johnson.and dogs ')
1225
1226 def test_get_local_part_complex_obsolete_invalid(self):
1227 local_part = self._test_get_x(parser.get_local_part,
1228 ' (foo )Fred (bar).(bird) A.(sheep)Johnson "and dogs"@python.org',
1229 ' (foo )Fred (bar).(bird) A.(sheep)Johnson "and dogs"',
1230 ' Fred . A. Johnson and dogs',
1231 [errors.InvalidHeaderDefect]*2,
1232 '@python.org')
1233 self.assertEqual(local_part.local_part, 'Fred.A.Johnson and dogs')
1234
1235 def test_get_local_part_empty_raises(self):
1236 with self.assertRaises(errors.HeaderParseError):
1237 parser.get_local_part('')
1238
1239 def test_get_local_part_no_part_raises(self):
1240 with self.assertRaises(errors.HeaderParseError):
1241 parser.get_local_part(' (foo) ')
1242
1243 def test_get_local_part_special_instead_raises(self):
1244 with self.assertRaises(errors.HeaderParseError):
1245 parser.get_local_part(' (foo) @python.org')
1246
1247 def test_get_local_part_trailing_dot(self):
1248 local_part = self._test_get_x(parser.get_local_part,
1249 ' [email protected]',
1250 ' borris.',
1251 ' borris.',
1252 [errors.InvalidHeaderDefect]*2,
1253 '@python.org')
1254 self.assertEqual(local_part.local_part, 'borris.')
1255
1256 def test_get_local_part_trailing_dot_with_ws(self):
1257 local_part = self._test_get_x(parser.get_local_part,
1258 ' borris. @python.org',
1259 ' borris. ',
1260 ' borris. ',
1261 [errors.InvalidHeaderDefect]*2,
1262 '@python.org')
1263 self.assertEqual(local_part.local_part, 'borris.')
1264
1265 def test_get_local_part_leading_dot(self):
1266 local_part = self._test_get_x(parser.get_local_part,
1267 '[email protected]',
1268 '.borris',
1269 '.borris',
1270 [errors.InvalidHeaderDefect]*2,
1271 '@python.org')
1272 self.assertEqual(local_part.local_part, '.borris')
1273
1274 def test_get_local_part_leading_dot_after_ws(self):
1275 local_part = self._test_get_x(parser.get_local_part,
1276 ' [email protected]',
1277 ' .borris',
1278 ' .borris',
1279 [errors.InvalidHeaderDefect]*2,
1280 '@python.org')
1281 self.assertEqual(local_part.local_part, '.borris')
1282
1283 def test_get_local_part_double_dot_raises(self):
1284 local_part = self._test_get_x(parser.get_local_part,
1285 ' borris.(foo)[email protected]',
1286 ' borris.(foo).natasha',
1287 ' borris. .natasha',
1288 [errors.InvalidHeaderDefect]*2,
1289 '@python.org')
1290 self.assertEqual(local_part.local_part, 'borris..natasha')
1291
1292 def test_get_local_part_quoted_strings_in_atom_list(self):
1293 local_part = self._test_get_x(parser.get_local_part,
1294 '""example" example"@example.com',
1295 '""example" example"',
1296 'example example',
1297 [errors.InvalidHeaderDefect]*3,
1298 '@example.com')
1299 self.assertEqual(local_part.local_part, 'example example')
1300
1301 def test_get_local_part_valid_and_invalid_qp_in_atom_list(self):
1302 local_part = self._test_get_x(parser.get_local_part,
1303 r'"\\"example\\" example"@example.com',
1304 r'"\\"example\\" example"',
1305 r'\example\\ example',
1306 [errors.InvalidHeaderDefect]*5,
1307 '@example.com')
1308 self.assertEqual(local_part.local_part, r'\example\\ example')
1309
1310 def test_get_local_part_unicode_defect(self):
1311 # Currently this only happens when parsing unicode, not when parsing
1312 # stuff that was originally binary.
1313 local_part = self._test_get_x(parser.get_local_part,
1314 'exá[email protected]',
1315 'exámple',
1316 'exámple',
1317 [errors.NonASCIILocalPartDefect],
1318 '@example.com')
1319 self.assertEqual(local_part.local_part, 'exámple')
1320
1321 # get_dtext
1322
1323 def test_get_dtext_only(self):
1324 dtext = self._test_get_x(parser.get_dtext,
1325 'foobar', 'foobar', 'foobar', [], '')
1326 self.assertEqual(dtext.token_type, 'ptext')
1327
1328 def test_get_dtext_all_dtext(self):
1329 dtext = self._test_get_x(parser.get_dtext, self.rfc_dtext_chars,
1330 self.rfc_dtext_chars,
1331 self.rfc_dtext_chars, [], '')
1332
1333 def test_get_dtext_two_words_gets_first(self):
1334 self._test_get_x(parser.get_dtext,
1335 'foo bar', 'foo', 'foo', [], ' bar')
1336
1337 def test_get_dtext_following_wsp_preserved(self):
1338 self._test_get_x(parser.get_dtext,
1339 'foo \t\tbar', 'foo', 'foo', [], ' \t\tbar')
1340
1341 def test_get_dtext_non_printables(self):
1342 dtext = self._test_get_x(parser.get_dtext,
1343 'foo\x00bar]', 'foo\x00bar', 'foo\x00bar',
1344 [errors.NonPrintableDefect], ']')
1345 self.assertEqual(dtext.defects[0].non_printables[0], '\x00')
1346
1347 def test_get_dtext_with_qp(self):
1348 ptext = self._test_get_x(parser.get_dtext,
1349 r'foo\]\[\\bar\b\e\l\l',
1350 r'foo][\barbell',
1351 r'foo][\barbell',
1352 [errors.ObsoleteHeaderDefect],
1353 '')
1354
1355 def test_get_dtext_up_to_close_bracket_only(self):
1356 self._test_get_x(parser.get_dtext,
1357 'foo]', 'foo', 'foo', [], ']')
1358
1359 def test_get_dtext_wsp_before_close_bracket_preserved(self):
1360 self._test_get_x(parser.get_dtext,
1361 'foo ]', 'foo', 'foo', [], ' ]')
1362
1363 def test_get_dtext_close_bracket_mid_word(self):
1364 self._test_get_x(parser.get_dtext,
1365 'foo]bar', 'foo', 'foo', [], ']bar')
1366
1367 def test_get_dtext_up_to_open_bracket_only(self):
1368 self._test_get_x(parser.get_dtext,
1369 'foo[', 'foo', 'foo', [], '[')
1370
1371 def test_get_dtext_wsp_before_open_bracket_preserved(self):
1372 self._test_get_x(parser.get_dtext,
1373 'foo [', 'foo', 'foo', [], ' [')
1374
1375 def test_get_dtext_open_bracket_mid_word(self):
1376 self._test_get_x(parser.get_dtext,
1377 'foo[bar', 'foo', 'foo', [], '[bar')
1378
1379 def test_get_dtext_open_bracket_only(self):
1380 self._test_get_x(parser.get_dtext,
1381 '[', '', '', [], '[')
1382
1383 def test_get_dtext_close_bracket_only(self):
1384 self._test_get_x(parser.get_dtext,
1385 ']', '', '', [], ']')
1386
1387 def test_get_dtext_empty(self):
1388 self._test_get_x(parser.get_dtext,
1389 '', '', '', [], '')
1390
1391 # get_domain_literal
1392
1393 def test_get_domain_literal_only(self):
1394 domain_literal = domain_literal = self._test_get_x(parser.get_domain_literal,
1395 '[127.0.0.1]',
1396 '[127.0.0.1]',
1397 '[127.0.0.1]',
1398 [],
1399 '')
1400 self.assertEqual(domain_literal.token_type, 'domain-literal')
1401 self.assertEqual(domain_literal.domain, '[127.0.0.1]')
1402 self.assertEqual(domain_literal.ip, '127.0.0.1')
1403
1404 def test_get_domain_literal_with_internal_ws(self):
1405 domain_literal = self._test_get_x(parser.get_domain_literal,
1406 '[ 127.0.0.1\t ]',
1407 '[ 127.0.0.1\t ]',
1408 '[ 127.0.0.1 ]',
1409 [],
1410 '')
1411 self.assertEqual(domain_literal.domain, '[127.0.0.1]')
1412 self.assertEqual(domain_literal.ip, '127.0.0.1')
1413
1414 def test_get_domain_literal_with_surrounding_cfws(self):
1415 domain_literal = self._test_get_x(parser.get_domain_literal,
1416 '(foo)[ 127.0.0.1] (bar)',
1417 '(foo)[ 127.0.0.1] (bar)',
1418 ' [ 127.0.0.1] ',
1419 [],
1420 '')
1421 self.assertEqual(domain_literal.domain, '[127.0.0.1]')
1422 self.assertEqual(domain_literal.ip, '127.0.0.1')
1423
1424 def test_get_domain_literal_no_start_char_raises(self):
1425 with self.assertRaises(errors.HeaderParseError):
1426 parser.get_domain_literal('(foo) ')
1427
1428 def test_get_domain_literal_no_start_char_before_special_raises(self):
1429 with self.assertRaises(errors.HeaderParseError):
1430 parser.get_domain_literal('(foo) @')
1431
1432 def test_get_domain_literal_bad_dtext_char_before_special_raises(self):
1433 with self.assertRaises(errors.HeaderParseError):
1434 parser.get_domain_literal('(foo) [abc[@')
1435
1436 # get_domain
1437
1438 def test_get_domain_regular_domain_only(self):
1439 domain = self._test_get_x(parser.get_domain,
1440 'example.com',
1441 'example.com',
1442 'example.com',
1443 [],
1444 '')
1445 self.assertEqual(domain.token_type, 'domain')
1446 self.assertEqual(domain.domain, 'example.com')
1447
1448 def test_get_domain_domain_literal_only(self):
1449 domain = self._test_get_x(parser.get_domain,
1450 '[127.0.0.1]',
1451 '[127.0.0.1]',
1452 '[127.0.0.1]',
1453 [],
1454 '')
1455 self.assertEqual(domain.token_type, 'domain')
1456 self.assertEqual(domain.domain, '[127.0.0.1]')
1457
1458 def test_get_domain_with_cfws(self):
1459 domain = self._test_get_x(parser.get_domain,
1460 '(foo) example.com(bar)\t',
1461 '(foo) example.com(bar)\t',
1462 ' example.com ',
1463 [],
1464 '')
1465 self.assertEqual(domain.domain, 'example.com')
1466
1467 def test_get_domain_domain_literal_with_cfws(self):
1468 domain = self._test_get_x(parser.get_domain,
1469 '(foo)[127.0.0.1]\t(bar)',
1470 '(foo)[127.0.0.1]\t(bar)',
1471 ' [127.0.0.1] ',
1472 [],
1473 '')
1474 self.assertEqual(domain.domain, '[127.0.0.1]')
1475
1476 def test_get_domain_domain_with_cfws_ends_at_special(self):
1477 domain = self._test_get_x(parser.get_domain,
1478 '(foo)example.com\t(bar), next',
1479 '(foo)example.com\t(bar)',
1480 ' example.com ',
1481 [],
1482 ', next')
1483 self.assertEqual(domain.domain, 'example.com')
1484
1485 def test_get_domain_domain_literal_with_cfws_ends_at_special(self):
1486 domain = self._test_get_x(parser.get_domain,
1487 '(foo)[127.0.0.1]\t(bar), next',
1488 '(foo)[127.0.0.1]\t(bar)',
1489 ' [127.0.0.1] ',
1490 [],
1491 ', next')
1492 self.assertEqual(domain.domain, '[127.0.0.1]')
1493
1494 def test_get_domain_obsolete(self):
1495 domain = self._test_get_x(parser.get_domain,
1496 '(foo) example . (bird)com(bar)\t',
1497 '(foo) example . (bird)com(bar)\t',
1498 ' example . com ',
1499 [errors.ObsoleteHeaderDefect],
1500 '')
1501 self.assertEqual(domain.domain, 'example.com')
1502
1503 def test_get_domain_empty_raises(self):
1504 with self.assertRaises(errors.HeaderParseError):
1505 parser.get_domain("")
1506
1507 def test_get_domain_no_non_cfws_raises(self):
1508 with self.assertRaises(errors.HeaderParseError):
1509 parser.get_domain(" (foo)\t")
1510
1511 def test_get_domain_no_atom_raises(self):
1512 with self.assertRaises(errors.HeaderParseError):
1513 parser.get_domain(" (foo)\t, broken")
1514
1515
1516 # get_addr_spec
1517
1518 def test_get_addr_spec_normal(self):
1519 addr_spec = self._test_get_x(parser.get_addr_spec,
1520 '[email protected]',
1521 '[email protected]',
1522 '[email protected]',
1523 [],
1524 '')
1525 self.assertEqual(addr_spec.token_type, 'addr-spec')
1526 self.assertEqual(addr_spec.local_part, 'dinsdale')
1527 self.assertEqual(addr_spec.domain, 'example.com')
1528 self.assertEqual(addr_spec.addr_spec, '[email protected]')
1529
1530 def test_get_addr_spec_with_doamin_literal(self):
1531 addr_spec = self._test_get_x(parser.get_addr_spec,
1532 'dinsdale@[127.0.0.1]',
1533 'dinsdale@[127.0.0.1]',
1534 'dinsdale@[127.0.0.1]',
1535 [],
1536 '')
1537 self.assertEqual(addr_spec.local_part, 'dinsdale')
1538 self.assertEqual(addr_spec.domain, '[127.0.0.1]')
1539 self.assertEqual(addr_spec.addr_spec, 'dinsdale@[127.0.0.1]')
1540
1541 def test_get_addr_spec_with_cfws(self):
1542 addr_spec = self._test_get_x(parser.get_addr_spec,
1543 '(foo) dinsdale(bar)@ (bird) example.com (bog)',
1544 '(foo) dinsdale(bar)@ (bird) example.com (bog)',
1545 ' [email protected] ',
1546 [],
1547 '')
1548 self.assertEqual(addr_spec.local_part, 'dinsdale')
1549 self.assertEqual(addr_spec.domain, 'example.com')
1550 self.assertEqual(addr_spec.addr_spec, '[email protected]')
1551
1552 def test_get_addr_spec_with_qouoted_string_and_cfws(self):
1553 addr_spec = self._test_get_x(parser.get_addr_spec,
1554 '(foo) "roy a bug"(bar)@ (bird) example.com (bog)',
1555 '(foo) "roy a bug"(bar)@ (bird) example.com (bog)',
1556 ' "roy a bug"@example.com ',
1557 [],
1558 '')
1559 self.assertEqual(addr_spec.local_part, 'roy a bug')
1560 self.assertEqual(addr_spec.domain, 'example.com')
1561 self.assertEqual(addr_spec.addr_spec, '"roy a bug"@example.com')
1562
1563 def test_get_addr_spec_ends_at_special(self):
1564 addr_spec = self._test_get_x(parser.get_addr_spec,
1565 '(foo) "roy a bug"(bar)@ (bird) example.com (bog) , next',
1566 '(foo) "roy a bug"(bar)@ (bird) example.com (bog) ',
1567 ' "roy a bug"@example.com ',
1568 [],
1569 ', next')
1570 self.assertEqual(addr_spec.local_part, 'roy a bug')
1571 self.assertEqual(addr_spec.domain, 'example.com')
1572 self.assertEqual(addr_spec.addr_spec, '"roy a bug"@example.com')
1573
1574 def test_get_addr_spec_quoted_strings_in_atom_list(self):
1575 addr_spec = self._test_get_x(parser.get_addr_spec,
1576 '""example" example"@example.com',
1577 '""example" example"@example.com',
1578 'example [email protected]',
1579 [errors.InvalidHeaderDefect]*3,
1580 '')
1581 self.assertEqual(addr_spec.local_part, 'example example')
1582 self.assertEqual(addr_spec.domain, 'example.com')
1583 self.assertEqual(addr_spec.addr_spec, '"example example"@example.com')
1584
1585 def test_get_addr_spec_dot_atom(self):
1586 addr_spec = self._test_get_x(parser.get_addr_spec,
1587 '[email protected]',
1588 '[email protected]',
1589 '[email protected]',
1590 [],
1591 '')
1592 self.assertEqual(addr_spec.local_part, 'star.a.star')
1593 self.assertEqual(addr_spec.domain, 'example.com')
1594 self.assertEqual(addr_spec.addr_spec, '[email protected]')
1595
1596 def test_get_addr_spec_multiple_domains(self):
1597 with self.assertRaises(errors.HeaderParseError):
1598 parser.get_addr_spec('[email protected]@example.com')
1599
1600 with self.assertRaises(errors.HeaderParseError):
1601 parser.get_addr_spec('star@[email protected]')
1602
1603 with self.assertRaises(errors.HeaderParseError):
1604 parser.get_addr_spec('[email protected]@example.com')
1605
1606 # get_obs_route
1607
1608 def test_get_obs_route_simple(self):
1609 obs_route = self._test_get_x(parser.get_obs_route,
1610 '@example.com, @two.example.com:',
1611 '@example.com, @two.example.com:',
1612 '@example.com, @two.example.com:',
1613 [],
1614 '')
1615 self.assertEqual(obs_route.token_type, 'obs-route')
1616 self.assertEqual(obs_route.domains, ['example.com', 'two.example.com'])
1617
1618 def test_get_obs_route_complex(self):
1619 obs_route = self._test_get_x(parser.get_obs_route,
1620 '(foo),, (blue)@example.com (bar),@two.(foo) example.com (bird):',
1621 '(foo),, (blue)@example.com (bar),@two.(foo) example.com (bird):',
1622 ' ,, @example.com ,@two. example.com :',
1623 [errors.ObsoleteHeaderDefect], # This is the obs-domain
1624 '')
1625 self.assertEqual(obs_route.token_type, 'obs-route')
1626 self.assertEqual(obs_route.domains, ['example.com', 'two.example.com'])
1627
1628 def test_get_obs_route_no_route_before_end_raises(self):
1629 with self.assertRaises(errors.HeaderParseError):
1630 parser.get_obs_route('(foo) @example.com,')
1631
1632 def test_get_obs_route_no_route_before_end_raises2(self):
1633 with self.assertRaises(errors.HeaderParseError):
1634 parser.get_obs_route('(foo) @example.com, (foo) ')
1635
1636 def test_get_obs_route_no_route_before_special_raises(self):
1637 with self.assertRaises(errors.HeaderParseError):
1638 parser.get_obs_route('(foo) [abc],')
1639
1640 def test_get_obs_route_no_route_before_special_raises2(self):
1641 with self.assertRaises(errors.HeaderParseError):
1642 parser.get_obs_route('(foo) @example.com [abc],')
1643
1644 def test_get_obs_route_no_domain_after_at_raises(self):
1645 with self.assertRaises(errors.HeaderParseError):
1646 parser.get_obs_route('@')
1647
1648 def test_get_obs_route_no_domain_after_at_raises2(self):
1649 with self.assertRaises(errors.HeaderParseError):
1650 parser.get_obs_route('@example.com, @')
1651
1652 # get_angle_addr
1653
1654 def test_get_angle_addr_simple(self):
1655 angle_addr = self._test_get_x(parser.get_angle_addr,
1656 '<[email protected]>',
1657 '<[email protected]>',
1658 '<[email protected]>',
1659 [],
1660 '')
1661 self.assertEqual(angle_addr.token_type, 'angle-addr')
1662 self.assertEqual(angle_addr.local_part, 'dinsdale')
1663 self.assertEqual(angle_addr.domain, 'example.com')
1664 self.assertIsNone(angle_addr.route)
1665 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1666
1667 def test_get_angle_addr_empty(self):
1668 angle_addr = self._test_get_x(parser.get_angle_addr,
1669 '<>',
1670 '<>',
1671 '<>',
1672 [errors.InvalidHeaderDefect],
1673 '')
1674 self.assertEqual(angle_addr.token_type, 'angle-addr')
1675 self.assertIsNone(angle_addr.local_part)
1676 self.assertIsNone(angle_addr.domain)
1677 self.assertIsNone(angle_addr.route)
1678 self.assertEqual(angle_addr.addr_spec, '<>')
1679
1680 def test_get_angle_addr_qs_only_quotes(self):
1681 angle_addr = self._test_get_x(parser.get_angle_addr,
1682 '<""@example.com>',
1683 '<""@example.com>',
1684 '<""@example.com>',
1685 [],
1686 '')
1687 self.assertEqual(angle_addr.token_type, 'angle-addr')
1688 self.assertEqual(angle_addr.local_part, '')
1689 self.assertEqual(angle_addr.domain, 'example.com')
1690 self.assertIsNone(angle_addr.route)
1691 self.assertEqual(angle_addr.addr_spec, '""@example.com')
1692
1693 def test_get_angle_addr_with_cfws(self):
1694 angle_addr = self._test_get_x(parser.get_angle_addr,
1695 ' (foo) <[email protected]>(bar)',
1696 ' (foo) <[email protected]>(bar)',
1697 ' <[email protected]> ',
1698 [],
1699 '')
1700 self.assertEqual(angle_addr.token_type, 'angle-addr')
1701 self.assertEqual(angle_addr.local_part, 'dinsdale')
1702 self.assertEqual(angle_addr.domain, 'example.com')
1703 self.assertIsNone(angle_addr.route)
1704 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1705
1706 def test_get_angle_addr_qs_and_domain_literal(self):
1707 angle_addr = self._test_get_x(parser.get_angle_addr,
1708 '<"Fred Perfect"@[127.0.0.1]>',
1709 '<"Fred Perfect"@[127.0.0.1]>',
1710 '<"Fred Perfect"@[127.0.0.1]>',
1711 [],
1712 '')
1713 self.assertEqual(angle_addr.local_part, 'Fred Perfect')
1714 self.assertEqual(angle_addr.domain, '[127.0.0.1]')
1715 self.assertIsNone(angle_addr.route)
1716 self.assertEqual(angle_addr.addr_spec, '"Fred Perfect"@[127.0.0.1]')
1717
1718 def test_get_angle_addr_internal_cfws(self):
1719 angle_addr = self._test_get_x(parser.get_angle_addr,
1720 '<(foo) [email protected](bar)>',
1721 '<(foo) [email protected](bar)>',
1722 '< [email protected] >',
1723 [],
1724 '')
1725 self.assertEqual(angle_addr.local_part, 'dinsdale')
1726 self.assertEqual(angle_addr.domain, 'example.com')
1727 self.assertIsNone(angle_addr.route)
1728 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1729
1730 def test_get_angle_addr_obs_route(self):
1731 angle_addr = self._test_get_x(parser.get_angle_addr,
1732 '(foo)<@example.com, (bird) @two.example.com: [email protected]> (bar) ',
1733 '(foo)<@example.com, (bird) @two.example.com: [email protected]> (bar) ',
1734 ' <@example.com, @two.example.com: [email protected]> ',
1735 [errors.ObsoleteHeaderDefect],
1736 '')
1737 self.assertEqual(angle_addr.local_part, 'dinsdale')
1738 self.assertEqual(angle_addr.domain, 'example.com')
1739 self.assertEqual(angle_addr.route, ['example.com', 'two.example.com'])
1740 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1741
1742 def test_get_angle_addr_missing_closing_angle(self):
1743 angle_addr = self._test_get_x(parser.get_angle_addr,
1744 '<[email protected]',
1745 '<[email protected]>',
1746 '<[email protected]>',
1747 [errors.InvalidHeaderDefect],
1748 '')
1749 self.assertEqual(angle_addr.local_part, 'dinsdale')
1750 self.assertEqual(angle_addr.domain, 'example.com')
1751 self.assertIsNone(angle_addr.route)
1752 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1753
1754 def test_get_angle_addr_missing_closing_angle_with_cfws(self):
1755 angle_addr = self._test_get_x(parser.get_angle_addr,
1756 '<[email protected] (foo)',
1757 '<[email protected] (foo)>',
1758 '<[email protected] >',
1759 [errors.InvalidHeaderDefect],
1760 '')
1761 self.assertEqual(angle_addr.local_part, 'dinsdale')
1762 self.assertEqual(angle_addr.domain, 'example.com')
1763 self.assertIsNone(angle_addr.route)
1764 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1765
1766 def test_get_angle_addr_ends_at_special(self):
1767 angle_addr = self._test_get_x(parser.get_angle_addr,
1768 '<[email protected]> (foo), next',
1769 '<[email protected]> (foo)',
1770 '<[email protected]> ',
1771 [],
1772 ', next')
1773 self.assertEqual(angle_addr.local_part, 'dinsdale')
1774 self.assertEqual(angle_addr.domain, 'example.com')
1775 self.assertIsNone(angle_addr.route)
1776 self.assertEqual(angle_addr.addr_spec, '[email protected]')
1777
1778 def test_get_angle_addr_empty_raise(self):
1779 with self.assertRaises(errors.HeaderParseError):
1780 parser.get_angle_addr('')
1781
1782 def test_get_angle_addr_left_angle_only_raise(self):
1783 with self.assertRaises(errors.HeaderParseError):
1784 parser.get_angle_addr('<')
1785
1786 def test_get_angle_addr_no_angle_raise(self):
1787 with self.assertRaises(errors.HeaderParseError):
1788 parser.get_angle_addr('(foo) ')
1789
1790 def test_get_angle_addr_no_angle_before_special_raises(self):
1791 with self.assertRaises(errors.HeaderParseError):
1792 parser.get_angle_addr('(foo) , next')
1793
1794 def test_get_angle_addr_no_angle_raises(self):
1795 with self.assertRaises(errors.HeaderParseError):
1796 parser.get_angle_addr('bar')
1797
1798 def test_get_angle_addr_special_after_angle_raises(self):
1799 with self.assertRaises(errors.HeaderParseError):
1800 parser.get_angle_addr('(foo) <, bar')
1801
1802 # get_display_name This is phrase but with a different value.
1803
1804 def test_get_display_name_simple(self):
1805 display_name = self._test_get_x(parser.get_display_name,
1806 'Fred A Johnson',
1807 'Fred A Johnson',
1808 'Fred A Johnson',
1809 [],
1810 '')
1811 self.assertEqual(display_name.token_type, 'display-name')
1812 self.assertEqual(display_name.display_name, 'Fred A Johnson')
1813
1814 def test_get_display_name_complex1(self):
1815 display_name = self._test_get_x(parser.get_display_name,
1816 '"Fred A. Johnson" is his name, oh.',
1817 '"Fred A. Johnson" is his name',
1818 '"Fred A. Johnson is his name"',
1819 [],
1820 ', oh.')
1821 self.assertEqual(display_name.token_type, 'display-name')
1822 self.assertEqual(display_name.display_name, 'Fred A. Johnson is his name')
1823
1824 def test_get_display_name_complex2(self):
1825 display_name = self._test_get_x(parser.get_display_name,
1826 ' (A) bird (in (my|your)) "hand " is messy\t<>\t',
1827 ' (A) bird (in (my|your)) "hand " is messy\t',
1828 ' "bird hand is messy" ',
1829 [],
1830 '<>\t')
1831 self.assertEqual(display_name[0][0].comments, ['A'])
1832 self.assertEqual(display_name[0][2].comments, ['in (my|your)'])
1833 self.assertEqual(display_name.display_name, 'bird hand is messy')
1834
1835 def test_get_display_name_obsolete(self):
1836 display_name = self._test_get_x(parser.get_display_name,
1837 'Fred A.(weird).O Johnson',
1838 'Fred A.(weird).O Johnson',
1839 '"Fred A. .O Johnson"',
1840 [errors.ObsoleteHeaderDefect]*3,
1841 '')
1842 self.assertEqual(len(display_name), 7)
1843 self.assertEqual(display_name[3].comments, ['weird'])
1844 self.assertEqual(display_name.display_name, 'Fred A. .O Johnson')
1845
1846 def test_get_display_name_pharse_must_start_with_word(self):
1847 display_name = self._test_get_x(parser.get_display_name,
1848 '(even weirder).name',
1849 '(even weirder).name',
1850 ' ".name"',
1851 [errors.InvalidHeaderDefect] + [errors.ObsoleteHeaderDefect]*2,
1852 '')
1853 self.assertEqual(len(display_name), 3)
1854 self.assertEqual(display_name[0].comments, ['even weirder'])
1855 self.assertEqual(display_name.display_name, '.name')
1856
1857 def test_get_display_name_ending_with_obsolete(self):
1858 display_name = self._test_get_x(parser.get_display_name,
1859 'simple phrase.(with trailing comment):boo',
1860 'simple phrase.(with trailing comment)',
1861 '"simple phrase." ',
1862 [errors.ObsoleteHeaderDefect]*2,
1863 ':boo')
1864 self.assertEqual(len(display_name), 4)
1865 self.assertEqual(display_name[3].comments, ['with trailing comment'])
1866 self.assertEqual(display_name.display_name, 'simple phrase.')
1867
1868 def test_get_display_name_for_invalid_address_field(self):
1869 # bpo-32178: Test that address fields starting with `:` don't cause
1870 # IndexError when parsing the display name.
1871 display_name = self._test_get_x(
1872 parser.get_display_name,
1873 ':Foo ', '', '', [errors.InvalidHeaderDefect], ':Foo ')
1874 self.assertEqual(display_name.value, '')
1875
1876 # get_name_addr
1877
1878 def test_get_name_addr_angle_addr_only(self):
1879 name_addr = self._test_get_x(parser.get_name_addr,
1880 '<[email protected]>',
1881 '<[email protected]>',
1882 '<[email protected]>',
1883 [],
1884 '')
1885 self.assertEqual(name_addr.token_type, 'name-addr')
1886 self.assertIsNone(name_addr.display_name)
1887 self.assertEqual(name_addr.local_part, 'dinsdale')
1888 self.assertEqual(name_addr.domain, 'example.com')
1889 self.assertIsNone(name_addr.route)
1890 self.assertEqual(name_addr.addr_spec, '[email protected]')
1891
1892 def test_get_name_addr_atom_name(self):
1893 name_addr = self._test_get_x(parser.get_name_addr,
1894 'Dinsdale <[email protected]>',
1895 'Dinsdale <[email protected]>',
1896 'Dinsdale <[email protected]>',
1897 [],
1898 '')
1899 self.assertEqual(name_addr.token_type, 'name-addr')
1900 self.assertEqual(name_addr.display_name, 'Dinsdale')
1901 self.assertEqual(name_addr.local_part, 'dinsdale')
1902 self.assertEqual(name_addr.domain, 'example.com')
1903 self.assertIsNone(name_addr.route)
1904 self.assertEqual(name_addr.addr_spec, '[email protected]')
1905
1906 def test_get_name_addr_atom_name_with_cfws(self):
1907 name_addr = self._test_get_x(parser.get_name_addr,
1908 '(foo) Dinsdale (bar) <[email protected]> (bird)',
1909 '(foo) Dinsdale (bar) <[email protected]> (bird)',
1910 ' Dinsdale <[email protected]> ',
1911 [],
1912 '')
1913 self.assertEqual(name_addr.display_name, 'Dinsdale')
1914 self.assertEqual(name_addr.local_part, 'dinsdale')
1915 self.assertEqual(name_addr.domain, 'example.com')
1916 self.assertIsNone(name_addr.route)
1917 self.assertEqual(name_addr.addr_spec, '[email protected]')
1918
1919 def test_get_name_addr_name_with_cfws_and_dots(self):
1920 name_addr = self._test_get_x(parser.get_name_addr,
1921 '(foo) Roy.A.Bear (bar) <[email protected]> (bird)',
1922 '(foo) Roy.A.Bear (bar) <[email protected]> (bird)',
1923 ' "Roy.A.Bear" <[email protected]> ',
1924 [errors.ObsoleteHeaderDefect]*2,
1925 '')
1926 self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
1927 self.assertEqual(name_addr.local_part, 'dinsdale')
1928 self.assertEqual(name_addr.domain, 'example.com')
1929 self.assertIsNone(name_addr.route)
1930 self.assertEqual(name_addr.addr_spec, '[email protected]')
1931
1932 def test_get_name_addr_qs_name(self):
1933 name_addr = self._test_get_x(parser.get_name_addr,
1934 '"Roy.A.Bear" <[email protected]>',
1935 '"Roy.A.Bear" <[email protected]>',
1936 '"Roy.A.Bear" <[email protected]>',
1937 [],
1938 '')
1939 self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
1940 self.assertEqual(name_addr.local_part, 'dinsdale')
1941 self.assertEqual(name_addr.domain, 'example.com')
1942 self.assertIsNone(name_addr.route)
1943 self.assertEqual(name_addr.addr_spec, '[email protected]')
1944
1945 def test_get_name_addr_ending_with_dot_without_space(self):
1946 name_addr = self._test_get_x(parser.get_name_addr,
1947 'John X.<[email protected]>',
1948 'John X.<[email protected]>',
1949 '"John X."<[email protected]>',
1950 [errors.ObsoleteHeaderDefect],
1951 '')
1952 self.assertEqual(name_addr.display_name, 'John X.')
1953 self.assertEqual(name_addr.local_part, 'jxd')
1954 self.assertEqual(name_addr.domain, 'example.com')
1955 self.assertIsNone(name_addr.route)
1956 self.assertEqual(name_addr.addr_spec, '[email protected]')
1957
1958 def test_get_name_addr_starting_with_dot(self):
1959 name_addr = self._test_get_x(parser.get_name_addr,
1960 '. Doe <[email protected]>',
1961 '. Doe <[email protected]>',
1962 '". Doe" <[email protected]>',
1963 [errors.InvalidHeaderDefect, errors.ObsoleteHeaderDefect],
1964 '')
1965 self.assertEqual(name_addr.display_name, '. Doe')
1966 self.assertEqual(name_addr.local_part, 'jxd')
1967 self.assertEqual(name_addr.domain, 'example.com')
1968 self.assertIsNone(name_addr.route)
1969 self.assertEqual(name_addr.addr_spec, '[email protected]')
1970
1971 def test_get_name_addr_with_route(self):
1972 name_addr = self._test_get_x(parser.get_name_addr,
1973 '"Roy.A.Bear" <@two.example.com: [email protected]>',
1974 '"Roy.A.Bear" <@two.example.com: [email protected]>',
1975 '"Roy.A.Bear" <@two.example.com: [email protected]>',
1976 [errors.ObsoleteHeaderDefect],
1977 '')
1978 self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
1979 self.assertEqual(name_addr.local_part, 'dinsdale')
1980 self.assertEqual(name_addr.domain, 'example.com')
1981 self.assertEqual(name_addr.route, ['two.example.com'])
1982 self.assertEqual(name_addr.addr_spec, '[email protected]')
1983
1984 def test_get_name_addr_ends_at_special(self):
1985 name_addr = self._test_get_x(parser.get_name_addr,
1986 '"Roy.A.Bear" <[email protected]>, next',
1987 '"Roy.A.Bear" <[email protected]>',
1988 '"Roy.A.Bear" <[email protected]>',
1989 [],
1990 ', next')
1991 self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
1992 self.assertEqual(name_addr.local_part, 'dinsdale')
1993 self.assertEqual(name_addr.domain, 'example.com')
1994 self.assertIsNone(name_addr.route)
1995 self.assertEqual(name_addr.addr_spec, '[email protected]')
1996
1997 def test_get_name_addr_empty_raises(self):
1998 with self.assertRaises(errors.HeaderParseError):
1999 parser.get_name_addr('')
2000
2001 def test_get_name_addr_no_content_raises(self):
2002 with self.assertRaises(errors.HeaderParseError):
2003 parser.get_name_addr(' (foo) ')
2004
2005 def test_get_name_addr_no_content_before_special_raises(self):
2006 with self.assertRaises(errors.HeaderParseError):
2007 parser.get_name_addr(' (foo) ,')
2008
2009 def test_get_name_addr_no_angle_after_display_name_raises(self):
2010 with self.assertRaises(errors.HeaderParseError):
2011 parser.get_name_addr('foo bar')
2012
2013 # get_mailbox
2014
2015 def test_get_mailbox_addr_spec_only(self):
2016 mailbox = self._test_get_x(parser.get_mailbox,
2017 '[email protected]',
2018 '[email protected]',
2019 '[email protected]',
2020 [],
2021 '')
2022 self.assertEqual(mailbox.token_type, 'mailbox')
2023 self.assertIsNone(mailbox.display_name)
2024 self.assertEqual(mailbox.local_part, 'dinsdale')
2025 self.assertEqual(mailbox.domain, 'example.com')
2026 self.assertIsNone(mailbox.route)
2027 self.assertEqual(mailbox.addr_spec, '[email protected]')
2028
2029 def test_get_mailbox_angle_addr_only(self):
2030 mailbox = self._test_get_x(parser.get_mailbox,
2031 '<[email protected]>',
2032 '<[email protected]>',
2033 '<[email protected]>',
2034 [],
2035 '')
2036 self.assertEqual(mailbox.token_type, 'mailbox')
2037 self.assertIsNone(mailbox.display_name)
2038 self.assertEqual(mailbox.local_part, 'dinsdale')
2039 self.assertEqual(mailbox.domain, 'example.com')
2040 self.assertIsNone(mailbox.route)
2041 self.assertEqual(mailbox.addr_spec, '[email protected]')
2042
2043 def test_get_mailbox_name_addr(self):
2044 mailbox = self._test_get_x(parser.get_mailbox,
2045 '"Roy A. Bear" <[email protected]>',
2046 '"Roy A. Bear" <[email protected]>',
2047 '"Roy A. Bear" <[email protected]>',
2048 [],
2049 '')
2050 self.assertEqual(mailbox.token_type, 'mailbox')
2051 self.assertEqual(mailbox.display_name, 'Roy A. Bear')
2052 self.assertEqual(mailbox.local_part, 'dinsdale')
2053 self.assertEqual(mailbox.domain, 'example.com')
2054 self.assertIsNone(mailbox.route)
2055 self.assertEqual(mailbox.addr_spec, '[email protected]')
2056
2057 def test_get_mailbox_ends_at_special(self):
2058 mailbox = self._test_get_x(parser.get_mailbox,
2059 '"Roy A. Bear" <[email protected]>, rest',
2060 '"Roy A. Bear" <[email protected]>',
2061 '"Roy A. Bear" <[email protected]>',
2062 [],
2063 ', rest')
2064 self.assertEqual(mailbox.token_type, 'mailbox')
2065 self.assertEqual(mailbox.display_name, 'Roy A. Bear')
2066 self.assertEqual(mailbox.local_part, 'dinsdale')
2067 self.assertEqual(mailbox.domain, 'example.com')
2068 self.assertIsNone(mailbox.route)
2069 self.assertEqual(mailbox.addr_spec, '[email protected]')
2070
2071 def test_get_mailbox_quoted_strings_in_atom_list(self):
2072 mailbox = self._test_get_x(parser.get_mailbox,
2073 '""example" example"@example.com',
2074 '""example" example"@example.com',
2075 'example [email protected]',
2076 [errors.InvalidHeaderDefect]*3,
2077 '')
2078 self.assertEqual(mailbox.local_part, 'example example')
2079 self.assertEqual(mailbox.domain, 'example.com')
2080 self.assertEqual(mailbox.addr_spec, '"example example"@example.com')
2081
2082 # get_mailbox_list
2083
2084 def test_get_mailbox_list_single_addr(self):
2085 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2086 '[email protected]',
2087 '[email protected]',
2088 '[email protected]',
2089 [],
2090 '')
2091 self.assertEqual(mailbox_list.token_type, 'mailbox-list')
2092 self.assertEqual(len(mailbox_list.mailboxes), 1)
2093 mailbox = mailbox_list.mailboxes[0]
2094 self.assertIsNone(mailbox.display_name)
2095 self.assertEqual(mailbox.local_part, 'dinsdale')
2096 self.assertEqual(mailbox.domain, 'example.com')
2097 self.assertIsNone(mailbox.route)
2098 self.assertEqual(mailbox.addr_spec, '[email protected]')
2099 self.assertEqual(mailbox_list.mailboxes,
2100 mailbox_list.all_mailboxes)
2101
2102 def test_get_mailbox_list_two_simple_addr(self):
2103 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2104 '[email protected], [email protected]',
2105 '[email protected], [email protected]',
2106 '[email protected], [email protected]',
2107 [],
2108 '')
2109 self.assertEqual(mailbox_list.token_type, 'mailbox-list')
2110 self.assertEqual(len(mailbox_list.mailboxes), 2)
2111 self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
2112 '[email protected]')
2113 self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
2114 '[email protected]')
2115 self.assertEqual(mailbox_list.mailboxes,
2116 mailbox_list.all_mailboxes)
2117
2118 def test_get_mailbox_list_two_name_addr(self):
2119 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2120 ('"Roy A. Bear" <[email protected]>,'
2121 ' "Fred Flintstone" <[email protected]>'),
2122 ('"Roy A. Bear" <[email protected]>,'
2123 ' "Fred Flintstone" <[email protected]>'),
2124 ('"Roy A. Bear" <[email protected]>,'
2125 ' "Fred Flintstone" <[email protected]>'),
2126 [],
2127 '')
2128 self.assertEqual(len(mailbox_list.mailboxes), 2)
2129 self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
2130 '[email protected]')
2131 self.assertEqual(mailbox_list.mailboxes[0].display_name,
2132 'Roy A. Bear')
2133 self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
2134 '[email protected]')
2135 self.assertEqual(mailbox_list.mailboxes[1].display_name,
2136 'Fred Flintstone')
2137 self.assertEqual(mailbox_list.mailboxes,
2138 mailbox_list.all_mailboxes)
2139
2140 def test_get_mailbox_list_two_complex(self):
2141 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2142 ('(foo) "Roy A. Bear" <[email protected]>(bar),'
2143 ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
2144 ('(foo) "Roy A. Bear" <[email protected]>(bar),'
2145 ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
2146 (' "Roy A. Bear" <[email protected]> ,'
2147 ' "Fred Flintstone" <dinsdale@test. example.com>'),
2148 [errors.ObsoleteHeaderDefect],
2149 '')
2150 self.assertEqual(len(mailbox_list.mailboxes), 2)
2151 self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
2152 '[email protected]')
2153 self.assertEqual(mailbox_list.mailboxes[0].display_name,
2154 'Roy A. Bear')
2155 self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
2156 '[email protected]')
2157 self.assertEqual(mailbox_list.mailboxes[1].display_name,
2158 'Fred Flintstone')
2159 self.assertEqual(mailbox_list.mailboxes,
2160 mailbox_list.all_mailboxes)
2161
2162 def test_get_mailbox_list_unparseable_mailbox_null(self):
2163 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2164 ('"Roy A. Bear"[] [email protected],'
2165 ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
2166 ('"Roy A. Bear"[] [email protected],'
2167 ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
2168 ('"Roy A. Bear"[] [email protected],'
2169 ' "Fred Flintstone" <dinsdale@test. example.com>'),
2170 [errors.InvalidHeaderDefect, # the 'extra' text after the local part
2171 errors.InvalidHeaderDefect, # the local part with no angle-addr
2172 errors.ObsoleteHeaderDefect, # period in extra text (example.com)
2173 errors.ObsoleteHeaderDefect], # (bird) in valid address.
2174 '')
2175 self.assertEqual(len(mailbox_list.mailboxes), 1)
2176 self.assertEqual(len(mailbox_list.all_mailboxes), 2)
2177 self.assertEqual(mailbox_list.all_mailboxes[0].token_type,
2178 'invalid-mailbox')
2179 self.assertIsNone(mailbox_list.all_mailboxes[0].display_name)
2180 self.assertEqual(mailbox_list.all_mailboxes[0].local_part,
2181 'Roy A. Bear')
2182 self.assertIsNone(mailbox_list.all_mailboxes[0].domain)
2183 self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
2184 '"Roy A. Bear"')
2185 self.assertIs(mailbox_list.all_mailboxes[1],
2186 mailbox_list.mailboxes[0])
2187 self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
2188 '[email protected]')
2189 self.assertEqual(mailbox_list.mailboxes[0].display_name,
2190 'Fred Flintstone')
2191
2192 def test_get_mailbox_list_junk_after_valid_address(self):
2193 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2194 ('"Roy A. Bear" <[email protected]>@@,'
2195 ' "Fred Flintstone" <[email protected]>'),
2196 ('"Roy A. Bear" <[email protected]>@@,'
2197 ' "Fred Flintstone" <[email protected]>'),
2198 ('"Roy A. Bear" <[email protected]>@@,'
2199 ' "Fred Flintstone" <[email protected]>'),
2200 [errors.InvalidHeaderDefect],
2201 '')
2202 self.assertEqual(len(mailbox_list.mailboxes), 1)
2203 self.assertEqual(len(mailbox_list.all_mailboxes), 2)
2204 self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
2205 '[email protected]')
2206 self.assertEqual(mailbox_list.all_mailboxes[0].display_name,
2207 'Roy A. Bear')
2208 self.assertEqual(mailbox_list.all_mailboxes[0].token_type,
2209 'invalid-mailbox')
2210 self.assertIs(mailbox_list.all_mailboxes[1],
2211 mailbox_list.mailboxes[0])
2212 self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
2213 '[email protected]')
2214 self.assertEqual(mailbox_list.mailboxes[0].display_name,
2215 'Fred Flintstone')
2216
2217 def test_get_mailbox_list_empty_list_element(self):
2218 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2219 ('"Roy A. Bear" <[email protected]>, (bird),,'
2220 ' "Fred Flintstone" <[email protected]>'),
2221 ('"Roy A. Bear" <[email protected]>, (bird),,'
2222 ' "Fred Flintstone" <[email protected]>'),
2223 ('"Roy A. Bear" <[email protected]>, ,,'
2224 ' "Fred Flintstone" <[email protected]>'),
2225 [errors.ObsoleteHeaderDefect]*2,
2226 '')
2227 self.assertEqual(len(mailbox_list.mailboxes), 2)
2228 self.assertEqual(mailbox_list.all_mailboxes,
2229 mailbox_list.mailboxes)
2230 self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
2231 '[email protected]')
2232 self.assertEqual(mailbox_list.all_mailboxes[0].display_name,
2233 'Roy A. Bear')
2234 self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
2235 '[email protected]')
2236 self.assertEqual(mailbox_list.mailboxes[1].display_name,
2237 'Fred Flintstone')
2238
2239 def test_get_mailbox_list_only_empty_elements(self):
2240 mailbox_list = self._test_get_x(parser.get_mailbox_list,
2241 '(foo),, (bar)',
2242 '(foo),, (bar)',
2243 ' ,, ',
2244 [errors.ObsoleteHeaderDefect]*3,
2245 '')
2246 self.assertEqual(len(mailbox_list.mailboxes), 0)
2247 self.assertEqual(mailbox_list.all_mailboxes,
2248 mailbox_list.mailboxes)
2249
2250 # get_group_list
2251
2252 def test_get_group_list_cfws_only(self):
2253 group_list = self._test_get_x(parser.get_group_list,
2254 '(hidden);',
2255 '(hidden)',
2256 ' ',
2257 [],
2258 ';')
2259 self.assertEqual(group_list.token_type, 'group-list')
2260 self.assertEqual(len(group_list.mailboxes), 0)
2261 self.assertEqual(group_list.mailboxes,
2262 group_list.all_mailboxes)
2263
2264 def test_get_group_list_mailbox_list(self):
2265 group_list = self._test_get_x(parser.get_group_list,
2266 '[email protected], "Fred A. Bear" <[email protected]>',
2267 '[email protected], "Fred A. Bear" <[email protected]>',
2268 '[email protected], "Fred A. Bear" <[email protected]>',
2269 [],
2270 '')
2271 self.assertEqual(group_list.token_type, 'group-list')
2272 self.assertEqual(len(group_list.mailboxes), 2)
2273 self.assertEqual(group_list.mailboxes,
2274 group_list.all_mailboxes)
2275 self.assertEqual(group_list.mailboxes[1].display_name,
2276 'Fred A. Bear')
2277
2278 def test_get_group_list_obs_group_list(self):
2279 group_list = self._test_get_x(parser.get_group_list,
2280 ', (foo),,(bar)',
2281 ', (foo),,(bar)',
2282 ', ,, ',
2283 [errors.ObsoleteHeaderDefect],
2284 '')
2285 self.assertEqual(group_list.token_type, 'group-list')
2286 self.assertEqual(len(group_list.mailboxes), 0)
2287 self.assertEqual(group_list.mailboxes,
2288 group_list.all_mailboxes)
2289
2290 def test_get_group_list_comment_only_invalid(self):
2291 group_list = self._test_get_x(parser.get_group_list,
2292 '(bar)',
2293 '(bar)',
2294 ' ',
2295 [errors.InvalidHeaderDefect],
2296 '')
2297 self.assertEqual(group_list.token_type, 'group-list')
2298 self.assertEqual(len(group_list.mailboxes), 0)
2299 self.assertEqual(group_list.mailboxes,
2300 group_list.all_mailboxes)
2301
2302 # get_group
2303
2304 def test_get_group_empty(self):
2305 group = self._test_get_x(parser.get_group,
2306 'Monty Python:;',
2307 'Monty Python:;',
2308 'Monty Python:;',
2309 [],
2310 '')
2311 self.assertEqual(group.token_type, 'group')
2312 self.assertEqual(group.display_name, 'Monty Python')
2313 self.assertEqual(len(group.mailboxes), 0)
2314 self.assertEqual(group.mailboxes,
2315 group.all_mailboxes)
2316
2317 def test_get_group_null_addr_spec(self):
2318 group = self._test_get_x(parser.get_group,
2319 'foo: <>;',
2320 'foo: <>;',
2321 'foo: <>;',
2322 [errors.InvalidHeaderDefect],
2323 '')
2324 self.assertEqual(group.display_name, 'foo')
2325 self.assertEqual(len(group.mailboxes), 0)
2326 self.assertEqual(len(group.all_mailboxes), 1)
2327 self.assertEqual(group.all_mailboxes[0].value, '<>')
2328
2329 def test_get_group_cfws_only(self):
2330 group = self._test_get_x(parser.get_group,
2331 'Monty Python: (hidden);',
2332 'Monty Python: (hidden);',
2333 'Monty Python: ;',
2334 [],
2335 '')
2336 self.assertEqual(group.token_type, 'group')
2337 self.assertEqual(group.display_name, 'Monty Python')
2338 self.assertEqual(len(group.mailboxes), 0)
2339 self.assertEqual(group.mailboxes,
2340 group.all_mailboxes)
2341
2342 def test_get_group_single_mailbox(self):
2343 group = self._test_get_x(parser.get_group,
2344 'Monty Python: "Fred A. Bear" <[email protected]>;',
2345 'Monty Python: "Fred A. Bear" <[email protected]>;',
2346 'Monty Python: "Fred A. Bear" <[email protected]>;',
2347 [],
2348 '')
2349 self.assertEqual(group.token_type, 'group')
2350 self.assertEqual(group.display_name, 'Monty Python')
2351 self.assertEqual(len(group.mailboxes), 1)
2352 self.assertEqual(group.mailboxes,
2353 group.all_mailboxes)
2354 self.assertEqual(group.mailboxes[0].addr_spec,
2355 '[email protected]')
2356
2357 def test_get_group_mixed_list(self):
2358 group = self._test_get_x(parser.get_group,
2359 ('Monty Python: "Fred A. Bear" <[email protected]>,'
2360 '(foo) Roger <[email protected]>, [email protected];'),
2361 ('Monty Python: "Fred A. Bear" <[email protected]>,'
2362 '(foo) Roger <[email protected]>, [email protected];'),
2363 ('Monty Python: "Fred A. Bear" <[email protected]>,'
2364 ' Roger <[email protected]>, [email protected];'),
2365 [],
2366 '')
2367 self.assertEqual(group.token_type, 'group')
2368 self.assertEqual(group.display_name, 'Monty Python')
2369 self.assertEqual(len(group.mailboxes), 3)
2370 self.assertEqual(group.mailboxes,
2371 group.all_mailboxes)
2372 self.assertEqual(group.mailboxes[0].display_name,
2373 'Fred A. Bear')
2374 self.assertEqual(group.mailboxes[1].display_name,
2375 'Roger')
2376 self.assertEqual(group.mailboxes[2].local_part, 'x')
2377
2378 def test_get_group_one_invalid(self):
2379 group = self._test_get_x(parser.get_group,
2380 ('Monty Python: "Fred A. Bear" <[email protected]>,'
2381 '(foo) Roger [email protected], [email protected];'),
2382 ('Monty Python: "Fred A. Bear" <[email protected]>,'
2383 '(foo) Roger [email protected], [email protected];'),
2384 ('Monty Python: "Fred A. Bear" <[email protected]>,'
2385 ' Roger [email protected], [email protected];'),
2386 [errors.InvalidHeaderDefect, # non-angle addr makes local part invalid
2387 errors.InvalidHeaderDefect], # and its not obs-local either: no dots.
2388 '')
2389 self.assertEqual(group.token_type, 'group')
2390 self.assertEqual(group.display_name, 'Monty Python')
2391 self.assertEqual(len(group.mailboxes), 2)
2392 self.assertEqual(len(group.all_mailboxes), 3)
2393 self.assertEqual(group.mailboxes[0].display_name,
2394 'Fred A. Bear')
2395 self.assertEqual(group.mailboxes[1].local_part, 'x')
2396 self.assertIsNone(group.all_mailboxes[1].display_name)
2397
2398 def test_get_group_missing_final_semicol(self):
2399 group = self._test_get_x(parser.get_group,
2400 ('Monty Python:"Fred A. Bear" <[email protected]>,'
2401 '[email protected],John <jdoe@test>'),
2402 ('Monty Python:"Fred A. Bear" <[email protected]>,'
2403 '[email protected],John <jdoe@test>;'),
2404 ('Monty Python:"Fred A. Bear" <[email protected]>,'
2405 '[email protected],John <jdoe@test>;'),
2406 [errors.InvalidHeaderDefect],
2407 '')
2408 self.assertEqual(group.token_type, 'group')
2409 self.assertEqual(group.display_name, 'Monty Python')
2410 self.assertEqual(len(group.mailboxes), 3)
2411 self.assertEqual(group.mailboxes,
2412 group.all_mailboxes)
2413 self.assertEqual(group.mailboxes[0].addr_spec,
2414 '[email protected]')
2415 self.assertEqual(group.mailboxes[0].display_name,
2416 'Fred A. Bear')
2417 self.assertEqual(group.mailboxes[1].addr_spec,
2418 '[email protected]')
2419 self.assertEqual(group.mailboxes[2].display_name,
2420 'John')
2421 self.assertEqual(group.mailboxes[2].addr_spec,
2422 'jdoe@test')
2423 # get_address
2424
2425 def test_get_address_simple(self):
2426 address = self._test_get_x(parser.get_address,
2427 '[email protected]',
2428 '[email protected]',
2429 '[email protected]',
2430 [],
2431 '')
2432 self.assertEqual(address.token_type, 'address')
2433 self.assertEqual(len(address.mailboxes), 1)
2434 self.assertEqual(address.mailboxes,
2435 address.all_mailboxes)
2436 self.assertEqual(address.mailboxes[0].domain,
2437 'example.com')
2438 self.assertEqual(address[0].token_type,
2439 'mailbox')
2440
2441 def test_get_address_complex(self):
2442 address = self._test_get_x(parser.get_address,
2443 '(foo) "Fred A. Bear" <(bird)[email protected]>',
2444 '(foo) "Fred A. Bear" <(bird)[email protected]>',
2445 ' "Fred A. Bear" < [email protected]>',
2446 [],
2447 '')
2448 self.assertEqual(address.token_type, 'address')
2449 self.assertEqual(len(address.mailboxes), 1)
2450 self.assertEqual(address.mailboxes,
2451 address.all_mailboxes)
2452 self.assertEqual(address.mailboxes[0].display_name,
2453 'Fred A. Bear')
2454 self.assertEqual(address[0].token_type,
2455 'mailbox')
2456
2457 def test_get_address_rfc2047_display_name(self):
2458 address = self._test_get_x(parser.get_address,
2459 '=?utf-8?q?=C3=89ric?= <[email protected]>',
2460 'Éric <[email protected]>',
2461 'Éric <[email protected]>',
2462 [],
2463 '')
2464 self.assertEqual(address.token_type, 'address')
2465 self.assertEqual(len(address.mailboxes), 1)
2466 self.assertEqual(address.mailboxes,
2467 address.all_mailboxes)
2468 self.assertEqual(address.mailboxes[0].display_name,
2469 'Éric')
2470 self.assertEqual(address[0].token_type,
2471 'mailbox')
2472
2473 def test_get_address_rfc2047_display_name_adjacent_ews(self):
2474 address = self._test_get_x(parser.get_address,
2475 '=?utf-8?q?B=C3=A9r?= =?utf-8?q?=C3=A9nice?= <[email protected]>',
2476 'Bérénice <[email protected]>',
2477 'Bérénice <[email protected]>',
2478 [],
2479 '')
2480 self.assertEqual(address.token_type, 'address')
2481 self.assertEqual(len(address.mailboxes), 1)
2482 self.assertEqual(address.mailboxes,
2483 address.all_mailboxes)
2484 self.assertEqual(address.mailboxes[0].display_name,
2485 'Bérénice')
2486 self.assertEqual(address[0].token_type,
2487 'mailbox')
2488
2489 def test_get_address_empty_group(self):
2490 address = self._test_get_x(parser.get_address,
2491 'Monty Python:;',
2492 'Monty Python:;',
2493 'Monty Python:;',
2494 [],
2495 '')
2496 self.assertEqual(address.token_type, 'address')
2497 self.assertEqual(len(address.mailboxes), 0)
2498 self.assertEqual(address.mailboxes,
2499 address.all_mailboxes)
2500 self.assertEqual(address[0].token_type,
2501 'group')
2502 self.assertEqual(address[0].display_name,
2503 'Monty Python')
2504
2505 def test_get_address_group(self):
2506 address = self._test_get_x(parser.get_address,
2507 'Monty Python: [email protected], [email protected];',
2508 'Monty Python: [email protected], [email protected];',
2509 'Monty Python: [email protected], [email protected];',
2510 [],
2511 '')
2512 self.assertEqual(address.token_type, 'address')
2513 self.assertEqual(len(address.mailboxes), 2)
2514 self.assertEqual(address.mailboxes,
2515 address.all_mailboxes)
2516 self.assertEqual(address[0].token_type,
2517 'group')
2518 self.assertEqual(address[0].display_name,
2519 'Monty Python')
2520 self.assertEqual(address.mailboxes[0].local_part, 'x')
2521
2522 def test_get_address_quoted_local_part(self):
2523 address = self._test_get_x(parser.get_address,
2524 '"foo bar"@example.com',
2525 '"foo bar"@example.com',
2526 '"foo bar"@example.com',
2527 [],
2528 '')
2529 self.assertEqual(address.token_type, 'address')
2530 self.assertEqual(len(address.mailboxes), 1)
2531 self.assertEqual(address.mailboxes,
2532 address.all_mailboxes)
2533 self.assertEqual(address.mailboxes[0].domain,
2534 'example.com')
2535 self.assertEqual(address.mailboxes[0].local_part,
2536 'foo bar')
2537 self.assertEqual(address[0].token_type, 'mailbox')
2538
2539 def test_get_address_ends_at_special(self):
2540 address = self._test_get_x(parser.get_address,
2541 '[email protected], next',
2542 '[email protected]',
2543 '[email protected]',
2544 [],
2545 ', next')
2546 self.assertEqual(address.token_type, 'address')
2547 self.assertEqual(len(address.mailboxes), 1)
2548 self.assertEqual(address.mailboxes,
2549 address.all_mailboxes)
2550 self.assertEqual(address.mailboxes[0].domain,
2551 'example.com')
2552 self.assertEqual(address[0].token_type, 'mailbox')
2553
2554 def test_get_address_invalid_mailbox_invalid(self):
2555 address = self._test_get_x(parser.get_address,
2556 'ping example.com, next',
2557 'ping example.com',
2558 'ping example.com',
2559 [errors.InvalidHeaderDefect, # addr-spec with no domain
2560 errors.InvalidHeaderDefect, # invalid local-part
2561 errors.InvalidHeaderDefect, # missing .s in local-part
2562 ],
2563 ', next')
2564 self.assertEqual(address.token_type, 'address')
2565 self.assertEqual(len(address.mailboxes), 0)
2566 self.assertEqual(len(address.all_mailboxes), 1)
2567 self.assertIsNone(address.all_mailboxes[0].domain)
2568 self.assertEqual(address.all_mailboxes[0].local_part, 'ping example.com')
2569 self.assertEqual(address[0].token_type, 'invalid-mailbox')
2570
2571 def test_get_address_quoted_strings_in_atom_list(self):
2572 address = self._test_get_x(parser.get_address,
2573 '""example" example"@example.com',
2574 '""example" example"@example.com',
2575 'example [email protected]',
2576 [errors.InvalidHeaderDefect]*3,
2577 '')
2578 self.assertEqual(address.all_mailboxes[0].local_part, 'example example')
2579 self.assertEqual(address.all_mailboxes[0].domain, 'example.com')
2580 self.assertEqual(address.all_mailboxes[0].addr_spec, '"example example"@example.com')
2581
2582 def test_get_address_with_invalid_domain(self):
2583 address = self._test_get_x(parser.get_address,
2584 '<T@[',
2585 '<T@[]>',
2586 '<T@[]>',
2587 [errors.InvalidHeaderDefect, # missing trailing '>' on angle-addr
2588 errors.InvalidHeaderDefect, # end of input inside domain-literal
2589 ],
2590 '')
2591 self.assertEqual(address.token_type, 'address')
2592 self.assertEqual(len(address.mailboxes), 0)
2593 self.assertEqual(len(address.all_mailboxes), 1)
2594 self.assertEqual(address.all_mailboxes[0].domain, '[]')
2595 self.assertEqual(address.all_mailboxes[0].local_part, 'T')
2596 self.assertEqual(address.all_mailboxes[0].token_type, 'invalid-mailbox')
2597 self.assertEqual(address[0].token_type, 'invalid-mailbox')
2598
2599 address = self._test_get_x(parser.get_address,
2600 '!an??:=m==fr2@[C',
2601 '!an??:=m==fr2@[C];',
2602 '!an??:=m==fr2@[C];',
2603 [errors.InvalidHeaderDefect, # end of header in group
2604 errors.InvalidHeaderDefect, # end of input inside domain-literal
2605 ],
2606 '')
2607 self.assertEqual(address.token_type, 'address')
2608 self.assertEqual(len(address.mailboxes), 0)
2609 self.assertEqual(len(address.all_mailboxes), 1)
2610 self.assertEqual(address.all_mailboxes[0].domain, '[C]')
2611 self.assertEqual(address.all_mailboxes[0].local_part, '=m==fr2')
2612 self.assertEqual(address.all_mailboxes[0].token_type, 'invalid-mailbox')
2613 self.assertEqual(address[0].token_type, 'group')
2614
2615 # get_address_list
2616
2617 def test_get_address_list_CFWS(self):
2618 address_list = self._test_get_x(parser.get_address_list,
2619 '(Recipient list suppressed)',
2620 '(Recipient list suppressed)',
2621 ' ',
2622 [errors.ObsoleteHeaderDefect], # no content in address list
2623 '')
2624 self.assertEqual(address_list.token_type, 'address-list')
2625 self.assertEqual(len(address_list.mailboxes), 0)
2626 self.assertEqual(address_list.mailboxes, address_list.all_mailboxes)
2627
2628 def test_get_address_list_mailboxes_simple(self):
2629 address_list = self._test_get_x(parser.get_address_list,
2630 '[email protected]',
2631 '[email protected]',
2632 '[email protected]',
2633 [],
2634 '')
2635 self.assertEqual(address_list.token_type, 'address-list')
2636 self.assertEqual(len(address_list.mailboxes), 1)
2637 self.assertEqual(address_list.mailboxes,
2638 address_list.all_mailboxes)
2639 self.assertEqual([str(x) for x in address_list.mailboxes],
2640 [str(x) for x in address_list.addresses])
2641 self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
2642 self.assertEqual(address_list[0].token_type, 'address')
2643 self.assertIsNone(address_list[0].display_name)
2644
2645 def test_get_address_list_mailboxes_two_simple(self):
2646 address_list = self._test_get_x(parser.get_address_list,
2647 '[email protected], "Fred A. Bar" <[email protected]>',
2648 '[email protected], "Fred A. Bar" <[email protected]>',
2649 '[email protected], "Fred A. Bar" <[email protected]>',
2650 [],
2651 '')
2652 self.assertEqual(address_list.token_type, 'address-list')
2653 self.assertEqual(len(address_list.mailboxes), 2)
2654 self.assertEqual(address_list.mailboxes,
2655 address_list.all_mailboxes)
2656 self.assertEqual([str(x) for x in address_list.mailboxes],
2657 [str(x) for x in address_list.addresses])
2658 self.assertEqual(address_list.mailboxes[0].local_part, 'foo')
2659 self.assertEqual(address_list.mailboxes[1].display_name, "Fred A. Bar")
2660
2661 def test_get_address_list_mailboxes_complex(self):
2662 address_list = self._test_get_x(parser.get_address_list,
2663 ('"Roy A. Bear" <[email protected]>, '
2664 '(ping) Foo <[email protected]>,'
2665 'Nobody Is. Special <y@(bird)example.(bad)com>'),
2666 ('"Roy A. Bear" <[email protected]>, '
2667 '(ping) Foo <[email protected]>,'
2668 'Nobody Is. Special <y@(bird)example.(bad)com>'),
2669 ('"Roy A. Bear" <[email protected]>, '
2670 'Foo <[email protected]>,'
2671 '"Nobody Is. Special" <y@example. com>'),
2672 [errors.ObsoleteHeaderDefect, # period in Is.
2673 errors.ObsoleteHeaderDefect], # cfws in domain
2674 '')
2675 self.assertEqual(address_list.token_type, 'address-list')
2676 self.assertEqual(len(address_list.mailboxes), 3)
2677 self.assertEqual(address_list.mailboxes,
2678 address_list.all_mailboxes)
2679 self.assertEqual([str(x) for x in address_list.mailboxes],
2680 [str(x) for x in address_list.addresses])
2681 self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
2682 self.assertEqual(address_list.mailboxes[0].token_type, 'mailbox')
2683 self.assertEqual(address_list.addresses[0].token_type, 'address')
2684 self.assertEqual(address_list.mailboxes[1].local_part, 'x')
2685 self.assertEqual(address_list.mailboxes[2].display_name,
2686 'Nobody Is. Special')
2687
2688 def test_get_address_list_mailboxes_invalid_addresses(self):
2689 address_list = self._test_get_x(parser.get_address_list,
2690 ('"Roy A. Bear" <[email protected]>, '
2691 '(ping) Foo [email protected][],'
2692 'Nobody Is. Special <(bird)example.(bad)com>'),
2693 ('"Roy A. Bear" <[email protected]>, '
2694 '(ping) Foo [email protected][],'
2695 'Nobody Is. Special <(bird)example.(bad)com>'),
2696 ('"Roy A. Bear" <[email protected]>, '
2697 'Foo [email protected][],'
2698 '"Nobody Is. Special" < example. com>'),
2699 [errors.InvalidHeaderDefect, # invalid address in list
2700 errors.InvalidHeaderDefect, # 'Foo x' local part invalid.
2701 errors.InvalidHeaderDefect, # Missing . in 'Foo x' local part
2702 errors.ObsoleteHeaderDefect, # period in 'Is.' disp-name phrase
2703 errors.InvalidHeaderDefect, # no domain part in addr-spec
2704 errors.ObsoleteHeaderDefect], # addr-spec has comment in it
2705 '')
2706 self.assertEqual(address_list.token_type, 'address-list')
2707 self.assertEqual(len(address_list.mailboxes), 1)
2708 self.assertEqual(len(address_list.all_mailboxes), 4)
2709 self.assertEqual([str(x) for x in address_list.all_mailboxes],
2710 [str(x) for x in address_list.addresses])
2711 self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
2712 self.assertEqual(address_list.mailboxes[0].token_type, 'mailbox')
2713 self.assertEqual(address_list.addresses[0].token_type, 'address')
2714 self.assertEqual(address_list.addresses[1].token_type, 'address')
2715 self.assertEqual(len(address_list.addresses[0].mailboxes), 1)
2716 self.assertEqual(len(address_list.addresses[1].mailboxes), 0)
2717 self.assertEqual(len(address_list.addresses[2].mailboxes), 0)
2718 self.assertEqual(len(address_list.addresses[3].mailboxes), 0)
2719 self.assertEqual(
2720 address_list.addresses[1].all_mailboxes[0].local_part, 'Foo x')
2721 self.assertEqual(address_list.addresses[2].all_mailboxes[0].value, '[]')
2722 self.assertEqual(
2723 address_list.addresses[3].all_mailboxes[0].display_name,
2724 "Nobody Is. Special")
2725
2726 def test_get_address_list_group_empty(self):
2727 address_list = self._test_get_x(parser.get_address_list,
2728 'Monty Python: ;',
2729 'Monty Python: ;',
2730 'Monty Python: ;',
2731 [],
2732 '')
2733 self.assertEqual(address_list.token_type, 'address-list')
2734 self.assertEqual(len(address_list.mailboxes), 0)
2735 self.assertEqual(address_list.mailboxes,
2736 address_list.all_mailboxes)
2737 self.assertEqual(len(address_list.addresses), 1)
2738 self.assertEqual(address_list.addresses[0].token_type, 'address')
2739 self.assertEqual(address_list.addresses[0].display_name, 'Monty Python')
2740 self.assertEqual(len(address_list.addresses[0].mailboxes), 0)
2741
2742 def test_get_address_list_group_simple(self):
2743 address_list = self._test_get_x(parser.get_address_list,
2744 'Monty Python: [email protected];',
2745 'Monty Python: [email protected];',
2746 'Monty Python: [email protected];',
2747 [],
2748 '')
2749 self.assertEqual(address_list.token_type, 'address-list')
2750 self.assertEqual(len(address_list.mailboxes), 1)
2751 self.assertEqual(address_list.mailboxes,
2752 address_list.all_mailboxes)
2753 self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
2754 self.assertEqual(address_list.addresses[0].display_name,
2755 'Monty Python')
2756 self.assertEqual(address_list.addresses[0].mailboxes[0].domain,
2757 'example.com')
2758
2759 def test_get_address_list_group_and_mailboxes(self):
2760 address_list = self._test_get_x(parser.get_address_list,
2761 ('Monty Python: [email protected], "Fred" <[email protected]>;, '
2762 'Abe <[email protected]>, Bee <[email protected]>'),
2763 ('Monty Python: [email protected], "Fred" <[email protected]>;, '
2764 'Abe <[email protected]>, Bee <[email protected]>'),
2765 ('Monty Python: [email protected], "Fred" <[email protected]>;, '
2766 'Abe <[email protected]>, Bee <[email protected]>'),
2767 [],
2768 '')
2769 self.assertEqual(address_list.token_type, 'address-list')
2770 self.assertEqual(len(address_list.mailboxes), 4)
2771 self.assertEqual(address_list.mailboxes,
2772 address_list.all_mailboxes)
2773 self.assertEqual(len(address_list.addresses), 3)
2774 self.assertEqual(address_list.mailboxes[0].local_part, 'dinsdale')
2775 self.assertEqual(address_list.addresses[0].display_name,
2776 'Monty Python')
2777 self.assertEqual(address_list.addresses[0].mailboxes[0].domain,
2778 'example.com')
2779 self.assertEqual(address_list.addresses[0].mailboxes[1].local_part,
2780 'flint')
2781 self.assertEqual(address_list.addresses[1].mailboxes[0].local_part,
2782 'x')
2783 self.assertEqual(address_list.addresses[2].mailboxes[0].local_part,
2784 'y')
2785 self.assertEqual(str(address_list.addresses[1]),
2786 str(address_list.mailboxes[2]))
2787
2788 def test_get_address_list_trailing_garbage(self):
2789 address_list = self._test_get_x(parser.get_address_list,
2790 'unlisted-recipients:; (no To-header on input)',
2791 'unlisted-recipients:; (no To-header on input)',
2792 'unlisted-recipients:; ',
2793 [errors.InvalidHeaderDefect]*2 + [errors.ObsoleteHeaderDefect],
2794 '')
2795
2796 def test_invalid_content_disposition(self):
2797 content_disp = self._test_parse_x(
2798 parser.parse_content_disposition_header,
2799 ";attachment", "; attachment", ";attachment",
2800 [errors.InvalidHeaderDefect]*2
2801 )
2802
2803 def test_invalid_content_transfer_encoding(self):
2804 cte = self._test_parse_x(
2805 parser.parse_content_transfer_encoding_header,
2806 ";foo", ";foo", ";foo", [errors.InvalidHeaderDefect]*3
2807 )
2808
2809 # get_msg_id
2810
2811 def test_get_msg_id_empty(self):
2812 # bpo-38708: Test that HeaderParseError is raised and not IndexError.
2813 with self.assertRaises(errors.HeaderParseError):
2814 parser.get_msg_id('')
2815
2816 def test_get_msg_id_valid(self):
2817 msg_id = self._test_get_x(
2818 parser.get_msg_id,
2819 "<[email protected]>",
2820 "<[email protected]>",
2821 "<[email protected]>",
2822 [],
2823 '',
2824 )
2825 self.assertEqual(msg_id.token_type, 'msg-id')
2826
2827 def test_get_msg_id_obsolete_local(self):
2828 msg_id = self._test_get_x(
2829 parser.get_msg_id,
2830 '<"simeple.local"@example.com>',
2831 '<"simeple.local"@example.com>',
2832 '<[email protected]>',
2833 [errors.ObsoleteHeaderDefect],
2834 '',
2835 )
2836 self.assertEqual(msg_id.token_type, 'msg-id')
2837
2838 def test_get_msg_id_non_folding_literal_domain(self):
2839 msg_id = self._test_get_x(
2840 parser.get_msg_id,
2841 "<simple.local@[someexamplecom.domain]>",
2842 "<simple.local@[someexamplecom.domain]>",
2843 "<simple.local@[someexamplecom.domain]>",
2844 [],
2845 "",
2846 )
2847 self.assertEqual(msg_id.token_type, 'msg-id')
2848
2849
2850 def test_get_msg_id_obsolete_domain_part(self):
2851 msg_id = self._test_get_x(
2852 parser.get_msg_id,
2853 "<simplelocal@(old)example.com>",
2854 "<simplelocal@(old)example.com>",
2855 "<simplelocal@ example.com>",
2856 [errors.ObsoleteHeaderDefect],
2857 ""
2858 )
2859
2860 def test_get_msg_id_no_id_right_part(self):
2861 msg_id = self._test_get_x(
2862 parser.get_msg_id,
2863 "<simplelocal>",
2864 "<simplelocal>",
2865 "<simplelocal>",
2866 [errors.InvalidHeaderDefect],
2867 ""
2868 )
2869 self.assertEqual(msg_id.token_type, 'msg-id')
2870
2871 def test_get_msg_id_invalid_expected_msg_id_not_found(self):
2872 text = "935-XPB-567:0:45327:9:90305:[email protected]"
2873 msg_id = parser.parse_message_id(text)
2874 self.assertDefectsEqual(
2875 msg_id.all_defects,
2876 [errors.InvalidHeaderDefect])
2877
2878 def test_parse_invalid_message_id(self):
2879 message_id = self._test_parse_x(
2880 parser.parse_message_id,
2881 "935-XPB-567:0:45327:9:90305:[email protected]",
2882 "935-XPB-567:0:45327:9:90305:[email protected]",
2883 "935-XPB-567:0:45327:9:90305:[email protected]",
2884 [errors.InvalidHeaderDefect],
2885 )
2886 self.assertEqual(message_id.token_type, 'invalid-message-id')
2887
2888 def test_parse_valid_message_id(self):
2889 message_id = self._test_parse_x(
2890 parser.parse_message_id,
2891 "<aperson@somedomain>",
2892 "<aperson@somedomain>",
2893 "<aperson@somedomain>",
2894 [],
2895 )
2896 self.assertEqual(message_id.token_type, 'message-id')
2897
2898 def test_parse_message_id_with_invalid_domain(self):
2899 message_id = self._test_parse_x(
2900 parser.parse_message_id,
2901 "<T@[",
2902 "<T@[]>",
2903 "<T@[]>",
2904 [errors.ObsoleteHeaderDefect] + [errors.InvalidHeaderDefect] * 2,
2905 [],
2906 )
2907 self.assertEqual(message_id.token_type, 'message-id')
2908 self.assertEqual(str(message_id.all_defects[-1]),
2909 "end of input inside domain-literal")
2910
2911 def test_parse_message_id_with_remaining(self):
2912 message_id = self._test_parse_x(
2913 parser.parse_message_id,
2914 "<validmessageid@example>thensomething",
2915 "<validmessageid@example>",
2916 "<validmessageid@example>",
2917 [errors.InvalidHeaderDefect],
2918 [],
2919 )
2920 self.assertEqual(message_id.token_type, 'message-id')
2921 self.assertEqual(str(message_id.all_defects[0]),
2922 "Unexpected 'thensomething'")
2923
2924 def test_get_msg_id_no_angle_start(self):
2925 with self.assertRaises(errors.HeaderParseError):
2926 parser.get_msg_id("msgwithnoankle")
2927
2928 def test_get_msg_id_no_angle_end(self):
2929 msg_id = self._test_get_x(
2930 parser.get_msg_id,
2931 "<simplelocal@domain",
2932 "<simplelocal@domain>",
2933 "<simplelocal@domain>",
2934 [errors.InvalidHeaderDefect],
2935 ""
2936 )
2937 self.assertEqual(msg_id.token_type, 'msg-id')
2938
2939 def test_get_msg_id_empty_id_left(self):
2940 with self.assertRaises(errors.HeaderParseError):
2941 parser.get_msg_id("<@domain>")
2942
2943 def test_get_msg_id_empty_id_right(self):
2944 with self.assertRaises(errors.HeaderParseError):
2945 parser.get_msg_id("<simplelocal@>")
2946
2947 def test_get_msg_id_no_id_right(self):
2948 with self.assertRaises(errors.HeaderParseError):
2949 parser.get_msg_id("<simplelocal@")
2950
2951 def test_get_msg_id_with_brackets(self):
2952 # Microsoft Outlook generates non-standard one-off addresses:
2953 # https://learn.microsoft.com/en-us/office/client-developer/outlook/mapi/one-off-addresses
2954 with self.assertRaises(errors.HeaderParseError):
2955 parser.get_msg_id("<[[email protected]]>")
2956
2957 def test_get_msg_id_ws_only_local(self):
2958 msg_id = self._test_get_x(
2959 parser.get_msg_id,
2960 "< @domain>",
2961 "< @domain>",
2962 "< @domain>",
2963 [errors.ObsoleteHeaderDefect],
2964 ""
2965 )
2966 self.assertEqual(msg_id.token_type, 'msg-id')
2967
2968 def test_parse_message_ids_valid(self):
2969 message_ids = self._test_parse_x(
2970 parser.parse_message_ids,
2971 "<foo@bar> <bar@foo>",
2972 "<foo@bar> <bar@foo>",
2973 "<foo@bar> <bar@foo>",
2974 [],
2975 )
2976 self.assertEqual(message_ids.token_type, 'message-id-list')
2977
2978 def test_parse_message_ids_empty(self):
2979 message_ids = self._test_parse_x(
2980 parser.parse_message_ids,
2981 " ",
2982 " ",
2983 " ",
2984 [errors.InvalidHeaderDefect],
2985 )
2986 self.assertEqual(message_ids.token_type, 'message-id-list')
2987
2988 def test_parse_message_ids_comment(self):
2989 message_ids = self._test_parse_x(
2990 parser.parse_message_ids,
2991 "<foo@bar> (foo's message from \"bar\")",
2992 "<foo@bar> (foo's message from \"bar\")",
2993 "<foo@bar> ",
2994 [],
2995 )
2996 self.assertEqual(message_ids.message_ids[0].value, '<foo@bar> ')
2997 self.assertEqual(message_ids.token_type, 'message-id-list')
2998
2999 def test_parse_message_ids_no_sep(self):
3000 message_ids = self._test_parse_x(
3001 parser.parse_message_ids,
3002 "<foo@bar><bar@foo>",
3003 "<foo@bar><bar@foo>",
3004 "<foo@bar><bar@foo>",
3005 [],
3006 )
3007 self.assertEqual(message_ids.message_ids[0].value, '<foo@bar>')
3008 self.assertEqual(message_ids.message_ids[1].value, '<bar@foo>')
3009 self.assertEqual(message_ids.token_type, 'message-id-list')
3010
3011 def test_parse_message_ids_comma_sep(self):
3012 message_ids = self._test_parse_x(
3013 parser.parse_message_ids,
3014 "<foo@bar>,<bar@foo>",
3015 "<foo@bar> <bar@foo>",
3016 "<foo@bar> <bar@foo>",
3017 [errors.InvalidHeaderDefect],
3018 )
3019 self.assertEqual(message_ids.message_ids[0].value, '<foo@bar>')
3020 self.assertEqual(message_ids.message_ids[1].value, '<bar@foo>')
3021 self.assertEqual(message_ids.token_type, 'message-id-list')
3022
3023 def test_parse_message_ids_invalid_id(self):
3024 message_ids = self._test_parse_x(
3025 parser.parse_message_ids,
3026 "<Date: Wed, 08 Jun 2002 09:78:58 +0600>",
3027 "<Date: Wed, 08 Jun 2002 09:78:58 +0600>",
3028 "<Date: Wed, 08 Jun 2002 09:78:58 +0600>",
3029 [errors.InvalidHeaderDefect]*2,
3030 )
3031 self.assertEqual(message_ids.token_type, 'message-id-list')
3032
3033 def test_parse_message_ids_broken_ang(self):
3034 message_ids = self._test_parse_x(
3035 parser.parse_message_ids,
3036 "<foo@bar> >bar@foo",
3037 "<foo@bar> >bar@foo",
3038 "<foo@bar> >bar@foo",
3039 [errors.InvalidHeaderDefect]*1,
3040 )
3041 self.assertEqual(message_ids.token_type, 'message-id-list')
3042
3043
3044
3045 @parameterize
3046 class Test_parse_mime_parameters(TestParserMixin, TestEmailBase):
3047
3048 def mime_parameters_as_value(self,
3049 value,
3050 tl_str,
3051 tl_value,
3052 params,
3053 defects):
3054 mime_parameters = self._test_parse_x(parser.parse_mime_parameters,
3055 value, tl_str, tl_value, defects)
3056 self.assertEqual(mime_parameters.token_type, 'mime-parameters')
3057 self.assertEqual(list(mime_parameters.params), params)
3058
3059
3060 mime_parameters_params = {
3061
3062 'simple': (
3063 'filename="abc.py"',
3064 ' filename="abc.py"',
3065 'filename=abc.py',
3066 [('filename', 'abc.py')],
3067 []),
3068
3069 'multiple_keys': (
3070 'filename="abc.py"; xyz=abc',
3071 ' filename="abc.py"; xyz="abc"',
3072 'filename=abc.py; xyz=abc',
3073 [('filename', 'abc.py'), ('xyz', 'abc')],
3074 []),
3075
3076 'split_value': (
3077 "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
3078 ' filename="201.tif"',
3079 "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
3080 [('filename', '201.tif')],
3081 []),
3082
3083 # Note that it is undefined what we should do for error recovery when
3084 # there are duplicate parameter names or duplicate parts in a split
3085 # part. We choose to ignore all duplicate parameters after the first
3086 # and to take duplicate or missing rfc 2231 parts in appearance order.
3087 # This is backward compatible with get_param's behavior, but the
3088 # decisions are arbitrary.
3089
3090 'duplicate_key': (
3091 'filename=abc.gif; filename=def.tiff',
3092 ' filename="abc.gif"',
3093 "filename=abc.gif; filename=def.tiff",
3094 [('filename', 'abc.gif')],
3095 [errors.InvalidHeaderDefect]),
3096
3097 'duplicate_key_with_split_value': (
3098 "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
3099 " filename=abc.gif",
3100 ' filename="201.tif"',
3101 "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
3102 " filename=abc.gif",
3103 [('filename', '201.tif')],
3104 [errors.InvalidHeaderDefect]),
3105
3106 'duplicate_key_with_split_value_other_order': (
3107 "filename=abc.gif; "
3108 " filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
3109 ' filename="abc.gif"',
3110 "filename=abc.gif;"
3111 " filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
3112 [('filename', 'abc.gif')],
3113 [errors.InvalidHeaderDefect]),
3114
3115 'duplicate_in_split_value': (
3116 "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
3117 " filename*1*=abc.gif",
3118 ' filename="201.tifabc.gif"',
3119 "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
3120 " filename*1*=abc.gif",
3121 [('filename', '201.tifabc.gif')],
3122 [errors.InvalidHeaderDefect]),
3123
3124 'missing_split_value': (
3125 "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;",
3126 ' filename="201.tif"',
3127 "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;",
3128 [('filename', '201.tif')],
3129 [errors.InvalidHeaderDefect]),
3130
3131 'duplicate_and_missing_split_value': (
3132 "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;"
3133 " filename*3*=abc.gif",
3134 ' filename="201.tifabc.gif"',
3135 "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;"
3136 " filename*3*=abc.gif",
3137 [('filename', '201.tifabc.gif')],
3138 [errors.InvalidHeaderDefect]*2),
3139
3140 # Here we depart from get_param and assume the *0* was missing.
3141 'duplicate_with_broken_split_value': (
3142 "filename=abc.gif; "
3143 " filename*2*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66",
3144 ' filename="abc.gif201.tif"',
3145 "filename=abc.gif;"
3146 " filename*2*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66",
3147 [('filename', 'abc.gif201.tif')],
3148 # Defects are apparent missing *0*, and two 'out of sequence'.
3149 [errors.InvalidHeaderDefect]*3),
3150
3151 # bpo-37461: Check that we don't go into an infinite loop.
3152 'extra_dquote': (
3153 'r*="\'a\'\\"',
3154 ' r="\\""',
3155 'r*=\'a\'"',
3156 [('r', '"')],
3157 [errors.InvalidHeaderDefect]*2),
3158 }
3159
3160 @parameterize
3161 class Test_parse_mime_version(TestParserMixin, TestEmailBase):
3162
3163 def mime_version_as_value(self,
3164 value,
3165 tl_str,
3166 tl_value,
3167 major,
3168 minor,
3169 defects):
3170 mime_version = self._test_parse_x(parser.parse_mime_version,
3171 value, tl_str, tl_value, defects)
3172 self.assertEqual(mime_version.major, major)
3173 self.assertEqual(mime_version.minor, minor)
3174
3175 mime_version_params = {
3176
3177 'rfc_2045_1': (
3178 '1.0',
3179 '1.0',
3180 '1.0',
3181 1,
3182 0,
3183 []),
3184
3185 'RFC_2045_2': (
3186 '1.0 (produced by MetaSend Vx.x)',
3187 '1.0 (produced by MetaSend Vx.x)',
3188 '1.0 ',
3189 1,
3190 0,
3191 []),
3192
3193 'RFC_2045_3': (
3194 '(produced by MetaSend Vx.x) 1.0',
3195 '(produced by MetaSend Vx.x) 1.0',
3196 ' 1.0',
3197 1,
3198 0,
3199 []),
3200
3201 'RFC_2045_4': (
3202 '1.(produced by MetaSend Vx.x)0',
3203 '1.(produced by MetaSend Vx.x)0',
3204 '1. 0',
3205 1,
3206 0,
3207 []),
3208
3209 'empty': (
3210 '',
3211 '',
3212 '',
3213 None,
3214 None,
3215 [errors.HeaderMissingRequiredValue]),
3216
3217 }
3218
3219
3220
3221 class TestFolding(TestEmailBase):
3222
3223 policy = policy.default
3224
3225 def _test(self, tl, folded, policy=policy):
3226 self.assertEqual(tl.fold(policy=policy), folded, tl.ppstr())
3227
3228 def test_simple_unstructured_no_folds(self):
3229 self._test(parser.get_unstructured("This is a test"),
3230 "This is a test\n")
3231
3232 def test_simple_unstructured_folded(self):
3233 self._test(parser.get_unstructured("This is also a test, but this "
3234 "time there are enough words (and even some "
3235 "symbols) to make it wrap; at least in theory."),
3236 "This is also a test, but this time there are enough "
3237 "words (and even some\n"
3238 " symbols) to make it wrap; at least in theory.\n")
3239
3240 def test_unstructured_with_unicode_no_folds(self):
3241 self._test(parser.get_unstructured("hübsch kleiner beißt"),
3242 "=?utf-8?q?h=C3=BCbsch_kleiner_bei=C3=9Ft?=\n")
3243
3244 def test_one_ew_on_each_of_two_wrapped_lines(self):
3245 self._test(parser.get_unstructured("Mein kleiner Kaktus ist sehr "
3246 "hübsch. Es hat viele Stacheln "
3247 "und oft beißt mich."),
3248 "Mein kleiner Kaktus ist sehr =?utf-8?q?h=C3=BCbsch=2E?= "
3249 "Es hat viele Stacheln\n"
3250 " und oft =?utf-8?q?bei=C3=9Ft?= mich.\n")
3251
3252 def test_ews_combined_before_wrap(self):
3253 self._test(parser.get_unstructured("Mein Kaktus ist hübsch. "
3254 "Es beißt mich. "
3255 "And that's all I'm sayin."),
3256 "Mein Kaktus ist =?utf-8?q?h=C3=BCbsch=2E__Es_bei=C3=9Ft?= "
3257 "mich. And that's\n"
3258 " all I'm sayin.\n")
3259
3260 def test_unicode_after_unknown_not_combined(self):
3261 self._test(parser.get_unstructured("=?unknown-8bit?q?=A4?=\xa4"),
3262 "=?unknown-8bit?q?=A4?==?utf-8?q?=C2=A4?=\n")
3263 prefix = "0123456789 "*5
3264 self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=A4?=\xa4"),
3265 prefix + "=?unknown-8bit?q?=A4?=\n =?utf-8?q?=C2=A4?=\n")
3266
3267 def test_ascii_after_unknown_not_combined(self):
3268 self._test(parser.get_unstructured("=?unknown-8bit?q?=A4?=abc"),
3269 "=?unknown-8bit?q?=A4?=abc\n")
3270 prefix = "0123456789 "*5
3271 self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=A4?=abc"),
3272 prefix + "=?unknown-8bit?q?=A4?=\n =?utf-8?q?abc?=\n")
3273
3274 def test_unknown_after_unicode_not_combined(self):
3275 self._test(parser.get_unstructured("\xa4"
3276 "=?unknown-8bit?q?=A4?="),
3277 "=?utf-8?q?=C2=A4?==?unknown-8bit?q?=A4?=\n")
3278 prefix = "0123456789 "*5
3279 self._test(parser.get_unstructured(prefix + "\xa4=?unknown-8bit?q?=A4?="),
3280 prefix + "=?utf-8?q?=C2=A4?=\n =?unknown-8bit?q?=A4?=\n")
3281
3282 def test_unknown_after_ascii_not_combined(self):
3283 self._test(parser.get_unstructured("abc"
3284 "=?unknown-8bit?q?=A4?="),
3285 "abc=?unknown-8bit?q?=A4?=\n")
3286 prefix = "0123456789 "*5
3287 self._test(parser.get_unstructured(prefix + "abcd=?unknown-8bit?q?=A4?="),
3288 prefix + "abcd\n =?unknown-8bit?q?=A4?=\n")
3289
3290 def test_unknown_after_unknown(self):
3291 self._test(parser.get_unstructured("=?unknown-8bit?q?=C2?="
3292 "=?unknown-8bit?q?=A4?="),
3293 "=?unknown-8bit?q?=C2=A4?=\n")
3294 prefix = "0123456789 "*5
3295 self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=C2?="
3296 "=?unknown-8bit?q?=A4?="),
3297 prefix + "=?unknown-8bit?q?=C2?=\n =?unknown-8bit?q?=A4?=\n")
3298
3299 # XXX Need test of an encoded word so long that it needs to be wrapped
3300
3301 def test_simple_address(self):
3302 self._test(parser.get_address_list("abc <[email protected]>")[0],
3303 "abc <[email protected]>\n")
3304
3305 def test_address_list_folding_at_commas(self):
3306 self._test(parser.get_address_list('abc <[email protected]>, '
3307 '"Fred Blunt" <[email protected]>, '
3308 '"J.P.Cool" <[email protected]>, '
3309 '"K<>y" <[email protected]>, '
3310 'Firesale <[email protected]>, '
3311 '<[email protected]>')[0],
3312 'abc <[email protected]>, "Fred Blunt" <[email protected]>,\n'
3313 ' "J.P.Cool" <[email protected]>, "K<>y" <[email protected]>,\n'
3314 ' Firesale <[email protected]>, <[email protected]>\n')
3315
3316 def test_address_list_with_unicode_names(self):
3317 self._test(parser.get_address_list(
3318 'Hübsch Kaktus <[email protected]>, '
3319 'beißt beißt <[email protected]>')[0],
3320 '=?utf-8?q?H=C3=BCbsch?= Kaktus <[email protected]>,\n'
3321 ' =?utf-8?q?bei=C3=9Ft_bei=C3=9Ft?= <[email protected]>\n')
3322
3323 def test_address_list_with_unicode_names_in_quotes(self):
3324 self._test(parser.get_address_list(
3325 '"Hübsch Kaktus" <[email protected]>, '
3326 '"beißt" beißt <[email protected]>')[0],
3327 '=?utf-8?q?H=C3=BCbsch?= Kaktus <[email protected]>,\n'
3328 ' =?utf-8?q?bei=C3=9Ft_bei=C3=9Ft?= <[email protected]>\n')
3329
3330 def test_address_list_with_specials_in_encoded_word(self):
3331 # An encoded-word parsed from a structured header must remain
3332 # encoded when it contains specials. Regression for gh-121284.
3333 policy = self.policy.clone(max_line_length=40)
3334 cases = [
3335 # (to, folded)
3336 ('=?utf-8?q?A_v=C3=A9ry_long_name_with=2C_comma?= <[email protected]>',
3337 'A =?utf-8?q?v=C3=A9ry_long_name_with?=\n'
3338 ' =?utf-8?q?=2C?= comma <[email protected]>\n'),
3339 ('=?utf-8?q?This_long_name_does_not_need_encoded=2Dword?= <[email protected]>',
3340 'This long name does not need\n'
3341 ' encoded-word <[email protected]>\n'),
3342 ('"A véry long name with, comma" <[email protected]>',
3343 # (This isn't the best fold point, but it's not invalid.)
3344 'A =?utf-8?q?v=C3=A9ry_long_name_with?=\n'
3345 ' =?utf-8?q?=2C?= comma <[email protected]>\n'),
3346 ('"A véry long name containing a, comma" <[email protected]>',
3347 'A =?utf-8?q?v=C3=A9ry?= long name\n'
3348 ' containing =?utf-8?q?a=2C?= comma\n'
3349 ' <[email protected]>\n'),
3350 ]
3351 for (to, folded) in cases:
3352 with self.subTest(to=to):
3353 self._test(parser.get_address_list(to)[0], folded, policy=policy)
3354
3355 def test_address_list_with_list_separator_after_fold(self):
3356 a = 'x' * 66 + '@example.com'
3357 to = f'{a}, "Hübsch Kaktus" <[email protected]>'
3358 self._test(parser.get_address_list(to)[0],
3359 f'{a},\n =?utf-8?q?H=C3=BCbsch?= Kaktus <[email protected]>\n')
3360
3361 a = '.' * 79 # ('.' is a special, so must be in quoted-string.)
3362 to = f'"{a}" <[email protected]>, "Hübsch Kaktus" <[email protected]>'
3363 self._test(parser.get_address_list(to)[0],
3364 f'"{a}"\n'
3365 ' <[email protected]>, =?utf-8?q?H=C3=BCbsch?= Kaktus '
3366 '<[email protected]>\n')
3367
3368 def test_address_list_with_specials_in_long_quoted_string(self):
3369 # Regression for gh-80222.
3370 policy = self.policy.clone(max_line_length=40)
3371 cases = [
3372 # (to, folded)
3373 ('"Exfiltrator <[email protected]> (unclosed comment?" <[email protected]>',
3374 '"Exfiltrator <[email protected]> (unclosed\n'
3375 ' comment?" <[email protected]>\n'),
3376 ('"Escaped \\" chars \\\\ in quoted-string stay escaped" <[email protected]>',
3377 '"Escaped \\" chars \\\\ in quoted-string\n'
3378 ' stay escaped" <[email protected]>\n'),
3379 ('This long display name does not need quotes <[email protected]>',
3380 'This long display name does not need\n'
3381 ' quotes <[email protected]>\n'),
3382 ('"Quotes are not required but are retained here" <[email protected]>',
3383 '"Quotes are not required but are\n'
3384 ' retained here" <[email protected]>\n'),
3385 ('"A quoted-string, it can be a valid local-part"@example.com',
3386 '"A quoted-string, it can be a valid\n'
3387 ' local-part"@example.com\n'),
3388 ('"[email protected]"@example.com',
3389 '"[email protected]"@example.com\n'),
3390 ]
3391 for (to, folded) in cases:
3392 with self.subTest(to=to):
3393 self._test(parser.get_address_list(to)[0], folded, policy=policy)
3394
3395 def test_address_list_with_long_unwrapable_comment(self):
3396 policy = self.policy.clone(max_line_length=40)
3397 cases = [
3398 # (to, folded)
3399 ('(loremipsumdolorsitametconsecteturadipi)<[email protected]>',
3400 '(loremipsumdolorsitametconsecteturadipi)<[email protected]>\n'),
3401 ('<[email protected]>(loremipsumdolorsitametconsecteturadipi)',
3402 '<[email protected]>(loremipsumdolorsitametconsecteturadipi)\n'),
3403 ('(loremipsum dolorsitametconsecteturadipi)<[email protected]>',
3404 '(loremipsum dolorsitametconsecteturadipi)<[email protected]>\n'),
3405 ('<[email protected]>(loremipsum dolorsitametconsecteturadipi)',
3406 '<[email protected]>(loremipsum\n dolorsitametconsecteturadipi)\n'),
3407 ('(Escaped \\( \\) chars \\\\ in comments stay escaped)<[email protected]>',
3408 '(Escaped \\( \\) chars \\\\ in comments stay\n escaped)<[email protected]>\n'),
3409 ('((loremipsum)(loremipsum)(loremipsum)(loremipsum))<[email protected]>',
3410 '((loremipsum)(loremipsum)(loremipsum)(loremipsum))<[email protected]>\n'),
3411 ('((loremipsum)(loremipsum)(loremipsum) (loremipsum))<[email protected]>',
3412 '((loremipsum)(loremipsum)(loremipsum)\n (loremipsum))<[email protected]>\n'),
3413 ]
3414 for (to, folded) in cases:
3415 with self.subTest(to=to):
3416 self._test(parser.get_address_list(to)[0], folded, policy=policy)
3417
3418 # XXX Need tests with comments on various sides of a unicode token,
3419 # and with unicode tokens in the comments. Spaces inside the quotes
3420 # currently don't do the right thing.
3421
3422 def test_split_at_whitespace_after_header_before_long_token(self):
3423 body = parser.get_unstructured(' ' + 'x'*77)
3424 header = parser.Header([
3425 parser.HeaderLabel([parser.ValueTerminal('test:', 'atext')]),
3426 parser.CFWSList([parser.WhiteSpaceTerminal(' ', 'fws')]), body])
3427 self._test(header, 'test: \n ' + 'x'*77 + '\n')
3428
3429 def test_split_at_whitespace_before_long_token(self):
3430 self._test(parser.get_unstructured('xxx ' + 'y'*77),
3431 'xxx \n ' + 'y'*77 + '\n')
3432
3433 def test_overlong_encodeable_is_wrapped(self):
3434 first_token_with_whitespace = 'xxx '
3435 chrome_leader = '=?utf-8?q?'
3436 len_chrome = len(chrome_leader) + 2
3437 len_non_y = len_chrome + len(first_token_with_whitespace)
3438 self._test(parser.get_unstructured(first_token_with_whitespace +
3439 'y'*80),
3440 first_token_with_whitespace + chrome_leader +
3441 'y'*(78-len_non_y) + '?=\n' +
3442 ' ' + chrome_leader + 'y'*(80-(78-len_non_y)) + '?=\n')
3443
3444 def test_long_filename_attachment(self):
3445 self._test(parser.parse_content_disposition_header(
3446 'attachment; filename="TEST_TEST_TEST_TEST'
3447 '_TEST_TEST_TEST_TEST_TEST_TEST_TEST_TEST_TES.txt"'),
3448 "attachment;\n"
3449 " filename*0*=us-ascii''TEST_TEST_TEST_TEST_TEST_TEST"
3450 "_TEST_TEST_TEST_TEST_TEST;\n"
3451 " filename*1*=_TEST_TES.txt\n",
3452 )
3453
3454 def test_fold_unfoldable_element_stealing_whitespace(self):
3455 # gh-142006: When an element is too long to fit on the current line
3456 # the previous line's trailing whitespace should not trigger a double newline.
3457 policy = self.policy.clone(max_line_length=10)
3458 # The non-whitespace text needs to exactly fill the max_line_length (10).
3459 text = ("a" * 9) + ", " + ("b" * 20)
3460 expected = ("a" * 9) + ",\n " + ("b" * 20) + "\n"
3461 token = parser.get_address_list(text)[0]
3462 self._test(token, expected, policy=policy)
3463
3464 def test_encoded_word_with_undecodable_bytes(self):
3465 self._test(parser.get_address_list(
3466 ' =?utf-8?Q?=E5=AE=A2=E6=88=B6=E6=AD=A3=E8=A6=8F=E4=BA=A4=E7?='
3467 )[0],
3468 ' =?unknown-8bit?b?5a6i5oi25q2j6KaP5Lqk5w==?=\n',
3469 )
3470
3471
3472 if __name__ == '__main__':
3473 unittest.main()