Debian Codegraph @

Lib/test/test_mailbox.py

raw
1 import os
2 import sys
3 import time
4 import socket
5 import email
6 import email.message
7 import re
8 import io
9 import tempfile
10 from test import support
11 from test.support import import_helper
12 from test.support import os_helper
13 from test.support import refleak_helper
14 from test.support import socket_helper
15 import unittest
16 import textwrap
17 import mailbox
18 import glob
19
20
21 if not socket_helper.has_gethostname:
22 raise unittest.SkipTest("test requires gethostname()")
23
24
25 class TestBase:
26
27 all_mailbox_types = (mailbox.Message, mailbox.MaildirMessage,
28 mailbox.mboxMessage, mailbox.MHMessage,
29 mailbox.BabylMessage, mailbox.MMDFMessage)
30
31 def _check_sample(self, msg):
32 # Inspect a mailbox.Message representation of the sample message
33 self.assertIsInstance(msg, email.message.Message)
34 self.assertIsInstance(msg, mailbox.Message)
35 for key, value in _sample_headers:
36 self.assertIn(value, msg.get_all(key))
37 self.assertTrue(msg.is_multipart())
38 self.assertEqual(len(msg.get_payload()), len(_sample_payloads))
39 for i, payload in enumerate(_sample_payloads):
40 part = msg.get_payload(i)
41 self.assertIsInstance(part, email.message.Message)
42 self.assertNotIsInstance(part, mailbox.Message)
43 self.assertEqual(part.get_payload(), payload)
44
45 def _delete_recursively(self, target):
46 # Delete a file or delete a directory recursively
47 if os.path.isdir(target):
48 os_helper.rmtree(target)
49 elif os.path.exists(target):
50 os_helper.unlink(target)
51
52
53 class TestMailbox(TestBase):
54
55 maxDiff = None
56
57 _factory = None # Overridden by subclasses to reuse tests
58 _template = 'From: foo\n\n%s\n'
59
60 def setUp(self):
61 self._path = os_helper.TESTFN
62 self._delete_recursively(self._path)
63 self._box = self._factory(self._path)
64
65 def tearDown(self):
66 self._box.close()
67 self._delete_recursively(self._path)
68
69 def test_add(self):
70 # Add copies of a sample message
71 keys = []
72 keys.append(self._box.add(self._template % 0))
73 self.assertEqual(len(self._box), 1)
74 keys.append(self._box.add(mailbox.Message(_sample_message)))
75 self.assertEqual(len(self._box), 2)
76 keys.append(self._box.add(email.message_from_string(_sample_message)))
77 self.assertEqual(len(self._box), 3)
78 keys.append(self._box.add(io.BytesIO(_bytes_sample_message)))
79 self.assertEqual(len(self._box), 4)
80 keys.append(self._box.add(_sample_message))
81 self.assertEqual(len(self._box), 5)
82 keys.append(self._box.add(_bytes_sample_message))
83 self.assertEqual(len(self._box), 6)
84 with self.assertWarns(DeprecationWarning):
85 keys.append(self._box.add(
86 io.TextIOWrapper(io.BytesIO(_bytes_sample_message), encoding="utf-8")))
87 self.assertEqual(len(self._box), 7)
88 self.assertEqual(self._box.get_string(keys[0]), self._template % 0)
89 for i in (1, 2, 3, 4, 5, 6):
90 self._check_sample(self._box[keys[i]])
91
92 _nonascii_msg = textwrap.dedent("""\
93 From: foo
94 Subject: Falinaptár házhozszállítással. Már rendeltél?
95
96 0
97 """)
98
99 def test_add_invalid_8bit_bytes_header(self):
100 key = self._box.add(self._nonascii_msg.encode('latin-1'))
101 self.assertEqual(len(self._box), 1)
102 self.assertEqual(self._box.get_bytes(key),
103 self._nonascii_msg.encode('latin-1'))
104
105 def test_invalid_nonascii_header_as_string(self):
106 subj = self._nonascii_msg.splitlines()[1]
107 key = self._box.add(subj.encode('latin-1'))
108 self.assertEqual(self._box.get_string(key),
109 'Subject: =?unknown-8bit?b?RmFsaW5hcHThciBo4Xpob3pzeuFsbO104XNz'
110 'YWwuIE3hciByZW5kZWx06Ww/?=\n\n')
111
112 def test_add_nonascii_string_header_raises(self):
113 with self.assertRaisesRegex(ValueError, "ASCII-only"):
114 self._box.add(self._nonascii_msg)
115 self._box.flush()
116 self.assertEqual(len(self._box), 0)
117 self.assertMailboxEmpty()
118
119 def test_add_that_raises_leaves_mailbox_empty(self):
120 class CustomError(Exception): ...
121 exc_msg = "a fake error"
122
123 def raiser(*args, **kw):
124 raise CustomError(exc_msg)
125 support.patch(self, email.generator.BytesGenerator, 'flatten', raiser)
126 with self.assertRaisesRegex(CustomError, exc_msg):
127 self._box.add(email.message_from_string("From: Alphöso"))
128 self.assertEqual(len(self._box), 0)
129 self._box.close()
130 self.assertMailboxEmpty()
131
132 _non_latin_bin_msg = textwrap.dedent("""\
133 From: [email protected]
134 To: báz
135 Subject: Maintenant je vous présente mon collègue, le pouf célèbre
136 \tJean de Baddie
137 Mime-Version: 1.0
138 Content-Type: text/plain; charset="utf-8"
139 Content-Transfer-Encoding: 8bit
140
141 Да, они летят.
142 """).encode('utf-8')
143
144 def test_add_8bit_body(self):
145 key = self._box.add(self._non_latin_bin_msg)
146 self.assertEqual(self._box.get_bytes(key),
147 self._non_latin_bin_msg)
148 with self._box.get_file(key) as f:
149 self.assertEqual(f.read(),
150 self._non_latin_bin_msg.replace(b'\n',
151 os.linesep.encode()))
152 self.assertEqual(self._box[key].get_payload(),
153 "Да, они летят.\n")
154
155 def test_add_binary_file(self):
156 with tempfile.TemporaryFile('wb+') as f:
157 f.write(_bytes_sample_message)
158 f.seek(0)
159 key = self._box.add(f)
160 self.assertEqual(self._box.get_bytes(key).split(b'\n'),
161 _bytes_sample_message.split(b'\n'))
162
163 def test_add_binary_nonascii_file(self):
164 with tempfile.TemporaryFile('wb+') as f:
165 f.write(self._non_latin_bin_msg)
166 f.seek(0)
167 key = self._box.add(f)
168 self.assertEqual(self._box.get_bytes(key).split(b'\n'),
169 self._non_latin_bin_msg.split(b'\n'))
170
171 def test_add_text_file_warns(self):
172 with tempfile.TemporaryFile('w+', encoding='utf-8') as f:
173 f.write(_sample_message)
174 f.seek(0)
175 with self.assertWarns(DeprecationWarning):
176 key = self._box.add(f)
177 self.assertEqual(self._box.get_bytes(key).split(b'\n'),
178 _bytes_sample_message.split(b'\n'))
179
180 def test_add_StringIO_warns(self):
181 with self.assertWarns(DeprecationWarning):
182 key = self._box.add(io.StringIO(self._template % "0"))
183 self.assertEqual(self._box.get_string(key), self._template % "0")
184
185 def test_add_nonascii_StringIO_raises(self):
186 with self.assertWarns(DeprecationWarning):
187 with self.assertRaisesRegex(ValueError, "ASCII-only"):
188 self._box.add(io.StringIO(self._nonascii_msg))
189 self.assertEqual(len(self._box), 0)
190 self._box.close()
191 self.assertMailboxEmpty()
192
193 def test_remove(self):
194 # Remove messages using remove()
195 self._test_remove_or_delitem(self._box.remove)
196
197 def test_delitem(self):
198 # Remove messages using __delitem__()
199 self._test_remove_or_delitem(self._box.__delitem__)
200
201 def _test_remove_or_delitem(self, method):
202 # (Used by test_remove() and test_delitem().)
203 key0 = self._box.add(self._template % 0)
204 key1 = self._box.add(self._template % 1)
205 self.assertEqual(len(self._box), 2)
206 method(key0)
207 self.assertEqual(len(self._box), 1)
208 self.assertRaises(KeyError, lambda: self._box[key0])
209 self.assertRaises(KeyError, lambda: method(key0))
210 self.assertEqual(self._box.get_string(key1), self._template % 1)
211 key2 = self._box.add(self._template % 2)
212 self.assertEqual(len(self._box), 2)
213 method(key2)
214 self.assertEqual(len(self._box), 1)
215 self.assertRaises(KeyError, lambda: self._box[key2])
216 self.assertRaises(KeyError, lambda: method(key2))
217 self.assertEqual(self._box.get_string(key1), self._template % 1)
218 method(key1)
219 self.assertEqual(len(self._box), 0)
220 self.assertRaises(KeyError, lambda: self._box[key1])
221 self.assertRaises(KeyError, lambda: method(key1))
222
223 def test_discard(self, repetitions=10):
224 # Discard messages
225 key0 = self._box.add(self._template % 0)
226 key1 = self._box.add(self._template % 1)
227 self.assertEqual(len(self._box), 2)
228 self._box.discard(key0)
229 self.assertEqual(len(self._box), 1)
230 self.assertRaises(KeyError, lambda: self._box[key0])
231 self._box.discard(key0)
232 self.assertEqual(len(self._box), 1)
233 self.assertRaises(KeyError, lambda: self._box[key0])
234
235 def test_get(self):
236 # Retrieve messages using get()
237 key0 = self._box.add(self._template % 0)
238 msg = self._box.get(key0)
239 self.assertEqual(msg['from'], 'foo')
240 self.assertEqual(msg.get_payload(), '0\n')
241 self.assertIsNone(self._box.get('foo'))
242 self.assertIs(self._box.get('foo', False), False)
243 self._box.close()
244 self._box = self._factory(self._path)
245 key1 = self._box.add(self._template % 1)
246 msg = self._box.get(key1)
247 self.assertEqual(msg['from'], 'foo')
248 self.assertEqual(msg.get_payload(), '1\n')
249
250 def test_getitem(self):
251 # Retrieve message using __getitem__()
252 key0 = self._box.add(self._template % 0)
253 msg = self._box[key0]
254 self.assertEqual(msg['from'], 'foo')
255 self.assertEqual(msg.get_payload(), '0\n')
256 self.assertRaises(KeyError, lambda: self._box['foo'])
257 self._box.discard(key0)
258 self.assertRaises(KeyError, lambda: self._box[key0])
259
260 def test_get_message(self):
261 # Get Message representations of messages
262 key0 = self._box.add(self._template % 0)
263 key1 = self._box.add(_sample_message)
264 msg0 = self._box.get_message(key0)
265 self.assertIsInstance(msg0, mailbox.Message)
266 self.assertEqual(msg0['from'], 'foo')
267 self.assertEqual(msg0.get_payload(), '0\n')
268 self._check_sample(self._box.get_message(key1))
269
270 def test_get_bytes(self):
271 # Get bytes representations of messages
272 key0 = self._box.add(self._template % 0)
273 key1 = self._box.add(_sample_message)
274 self.assertEqual(self._box.get_bytes(key0),
275 (self._template % 0).encode('ascii'))
276 self.assertEqual(self._box.get_bytes(key1), _bytes_sample_message)
277
278 def test_get_string(self):
279 # Get string representations of messages
280 key0 = self._box.add(self._template % 0)
281 key1 = self._box.add(_sample_message)
282 self.assertEqual(self._box.get_string(key0), self._template % 0)
283 self.assertEqual(self._box.get_string(key1).split('\n'),
284 _sample_message.split('\n'))
285
286 def test_get_file(self):
287 # Get file representations of messages
288 key0 = self._box.add(self._template % 0)
289 key1 = self._box.add(_sample_message)
290 with self._box.get_file(key0) as file:
291 data0 = file.read()
292 with self._box.get_file(key1) as file:
293 data1 = file.read()
294 self.assertEqual(data0.decode('ascii').replace(os.linesep, '\n'),
295 self._template % 0)
296 self.assertEqual(data1.decode('ascii').replace(os.linesep, '\n'),
297 _sample_message)
298
299 def test_get_file_can_be_closed_twice(self):
300 # Issue 11700
301 key = self._box.add(_sample_message)
302 f = self._box.get_file(key)
303 f.close()
304 f.close()
305
306 def test_iterkeys(self):
307 # Get keys using iterkeys()
308 self._check_iteration(self._box.iterkeys, do_keys=True, do_values=False)
309
310 def test_keys(self):
311 # Get keys using keys()
312 self._check_iteration(self._box.keys, do_keys=True, do_values=False)
313
314 def test_itervalues(self):
315 # Get values using itervalues()
316 self._check_iteration(self._box.itervalues, do_keys=False,
317 do_values=True)
318
319 def test_iter(self):
320 # Get values using __iter__()
321 self._check_iteration(self._box.__iter__, do_keys=False,
322 do_values=True)
323
324 def test_values(self):
325 # Get values using values()
326 self._check_iteration(self._box.values, do_keys=False, do_values=True)
327
328 def test_iteritems(self):
329 # Get keys and values using iteritems()
330 self._check_iteration(self._box.iteritems, do_keys=True,
331 do_values=True)
332
333 def test_items(self):
334 # Get keys and values using items()
335 self._check_iteration(self._box.items, do_keys=True, do_values=True)
336
337 def _check_iteration(self, method, do_keys, do_values, repetitions=10):
338 for value in method():
339 self.fail("Not empty")
340 keys, values = [], []
341 for i in range(repetitions):
342 keys.append(self._box.add(self._template % i))
343 values.append(self._template % i)
344 if do_keys and not do_values:
345 returned_keys = list(method())
346 elif do_values and not do_keys:
347 returned_values = list(method())
348 else:
349 returned_keys, returned_values = [], []
350 for key, value in method():
351 returned_keys.append(key)
352 returned_values.append(value)
353 if do_keys:
354 self.assertEqual(len(keys), len(returned_keys))
355 self.assertEqual(set(keys), set(returned_keys))
356 if do_values:
357 count = 0
358 for value in returned_values:
359 self.assertEqual(value['from'], 'foo')
360 self.assertLess(int(value.get_payload()), repetitions)
361 count += 1
362 self.assertEqual(len(values), count)
363
364 def test_contains(self):
365 # Check existence of keys using __contains__()
366 self.assertNotIn('foo', self._box)
367 key0 = self._box.add(self._template % 0)
368 self.assertIn(key0, self._box)
369 self.assertNotIn('foo', self._box)
370 key1 = self._box.add(self._template % 1)
371 self.assertIn(key1, self._box)
372 self.assertIn(key0, self._box)
373 self.assertNotIn('foo', self._box)
374 self._box.remove(key0)
375 self.assertNotIn(key0, self._box)
376 self.assertIn(key1, self._box)
377 self.assertNotIn('foo', self._box)
378 self._box.remove(key1)
379 self.assertNotIn(key1, self._box)
380 self.assertNotIn(key0, self._box)
381 self.assertNotIn('foo', self._box)
382
383 def test_len(self, repetitions=10):
384 # Get message count
385 keys = []
386 for i in range(repetitions):
387 self.assertEqual(len(self._box), i)
388 keys.append(self._box.add(self._template % i))
389 self.assertEqual(len(self._box), i + 1)
390 for i in range(repetitions):
391 self.assertEqual(len(self._box), repetitions - i)
392 self._box.remove(keys[i])
393 self.assertEqual(len(self._box), repetitions - i - 1)
394
395 def test_set_item(self):
396 # Modify messages using __setitem__()
397 key0 = self._box.add(self._template % 'original 0')
398 self.assertEqual(self._box.get_string(key0),
399 self._template % 'original 0')
400 key1 = self._box.add(self._template % 'original 1')
401 self.assertEqual(self._box.get_string(key1),
402 self._template % 'original 1')
403 self._box[key0] = self._template % 'changed 0'
404 self.assertEqual(self._box.get_string(key0),
405 self._template % 'changed 0')
406 self._box[key1] = self._template % 'changed 1'
407 self.assertEqual(self._box.get_string(key1),
408 self._template % 'changed 1')
409 self._box[key0] = _sample_message
410 self._check_sample(self._box[key0])
411 self._box[key1] = self._box[key0]
412 self._check_sample(self._box[key1])
413 self._box[key0] = self._template % 'original 0'
414 self.assertEqual(self._box.get_string(key0),
415 self._template % 'original 0')
416 self._check_sample(self._box[key1])
417 self.assertRaises(KeyError,
418 lambda: self._box.__setitem__('foo', 'bar'))
419 self.assertRaises(KeyError, lambda: self._box['foo'])
420 self.assertEqual(len(self._box), 2)
421
422 def test_clear(self, iterations=10):
423 # Remove all messages using clear()
424 keys = []
425 for i in range(iterations):
426 self._box.add(self._template % i)
427 for i, key in enumerate(keys):
428 self.assertEqual(self._box.get_string(key), self._template % i)
429 self._box.clear()
430 self.assertEqual(len(self._box), 0)
431 for i, key in enumerate(keys):
432 self.assertRaises(KeyError, lambda: self._box.get_string(key))
433
434 def test_pop(self):
435 # Get and remove a message using pop()
436 key0 = self._box.add(self._template % 0)
437 self.assertIn(key0, self._box)
438 key1 = self._box.add(self._template % 1)
439 self.assertIn(key1, self._box)
440 self.assertEqual(self._box.pop(key0).get_payload(), '0\n')
441 self.assertNotIn(key0, self._box)
442 self.assertIn(key1, self._box)
443 key2 = self._box.add(self._template % 2)
444 self.assertIn(key2, self._box)
445 self.assertEqual(self._box.pop(key2).get_payload(), '2\n')
446 self.assertNotIn(key2, self._box)
447 self.assertIn(key1, self._box)
448 self.assertEqual(self._box.pop(key1).get_payload(), '1\n')
449 self.assertNotIn(key1, self._box)
450 self.assertEqual(len(self._box), 0)
451
452 def test_popitem(self, iterations=10):
453 # Get and remove an arbitrary (key, message) using popitem()
454 keys = []
455 for i in range(10):
456 keys.append(self._box.add(self._template % i))
457 seen = []
458 for i in range(10):
459 key, msg = self._box.popitem()
460 self.assertIn(key, keys)
461 self.assertNotIn(key, seen)
462 seen.append(key)
463 self.assertEqual(int(msg.get_payload()), keys.index(key))
464 self.assertEqual(len(self._box), 0)
465 for key in keys:
466 self.assertRaises(KeyError, lambda: self._box[key])
467
468 def test_update(self):
469 # Modify multiple messages using update()
470 key0 = self._box.add(self._template % 'original 0')
471 key1 = self._box.add(self._template % 'original 1')
472 key2 = self._box.add(self._template % 'original 2')
473 self._box.update({key0: self._template % 'changed 0',
474 key2: _sample_message})
475 self.assertEqual(len(self._box), 3)
476 self.assertEqual(self._box.get_string(key0),
477 self._template % 'changed 0')
478 self.assertEqual(self._box.get_string(key1),
479 self._template % 'original 1')
480 self._check_sample(self._box[key2])
481 self._box.update([(key2, self._template % 'changed 2'),
482 (key1, self._template % 'changed 1'),
483 (key0, self._template % 'original 0')])
484 self.assertEqual(len(self._box), 3)
485 self.assertEqual(self._box.get_string(key0),
486 self._template % 'original 0')
487 self.assertEqual(self._box.get_string(key1),
488 self._template % 'changed 1')
489 self.assertEqual(self._box.get_string(key2),
490 self._template % 'changed 2')
491 self.assertRaises(KeyError,
492 lambda: self._box.update({'foo': 'bar',
493 key0: self._template % "changed 0"}))
494 self.assertEqual(len(self._box), 3)
495 self.assertEqual(self._box.get_string(key0),
496 self._template % "changed 0")
497 self.assertEqual(self._box.get_string(key1),
498 self._template % "changed 1")
499 self.assertEqual(self._box.get_string(key2),
500 self._template % "changed 2")
501
502 def test_flush(self):
503 # Write changes to disk
504 self._test_flush_or_close(self._box.flush, True)
505
506 def test_popitem_and_flush_twice(self):
507 # See #15036.
508 self._box.add(self._template % 0)
509 self._box.add(self._template % 1)
510 self._box.flush()
511
512 self._box.popitem()
513 self._box.flush()
514 self._box.popitem()
515 self._box.flush()
516
517 def test_lock_unlock(self):
518 # Lock and unlock the mailbox
519 self.assertFalse(os.path.exists(self._get_lock_path()))
520 self._box.lock()
521 self.assertTrue(os.path.exists(self._get_lock_path()))
522 self._box.unlock()
523 self.assertFalse(os.path.exists(self._get_lock_path()))
524
525 def test_close(self):
526 # Close mailbox and flush changes to disk
527 self._test_flush_or_close(self._box.close, False)
528
529 def _test_flush_or_close(self, method, should_call_close):
530 contents = [self._template % i for i in range(3)]
531 self._box.add(contents[0])
532 self._box.add(contents[1])
533 self._box.add(contents[2])
534 oldbox = self._box
535 method()
536 if should_call_close:
537 self._box.close()
538 self._box = self._factory(self._path)
539 keys = self._box.keys()
540 self.assertEqual(len(keys), 3)
541 for key in keys:
542 self.assertIn(self._box.get_string(key), contents)
543 oldbox.close()
544
545 def test_dump_message(self):
546 # Write message representations to disk
547 for input in (email.message_from_string(_sample_message),
548 _sample_message, io.BytesIO(_bytes_sample_message)):
549 output = io.BytesIO()
550 self._box._dump_message(input, output)
551 self.assertEqual(output.getvalue(),
552 _bytes_sample_message.replace(b'\n', os.linesep.encode()))
553 output = io.BytesIO()
554 self.assertRaises(TypeError,
555 lambda: self._box._dump_message(None, output))
556
557 def _get_lock_path(self):
558 # Return the path of the dot lock file. May be overridden.
559 return self._path + '.lock'
560
561
562 class TestMailboxSuperclass(TestBase, unittest.TestCase):
563
564 def test_notimplemented(self):
565 # Test that all Mailbox methods raise NotImplementedException.
566 box = mailbox.Mailbox('path')
567 self.assertRaises(NotImplementedError, lambda: box.add(''))
568 self.assertRaises(NotImplementedError, lambda: box.remove(''))
569 self.assertRaises(NotImplementedError, lambda: box.__delitem__(''))
570 self.assertRaises(NotImplementedError, lambda: box.discard(''))
571 self.assertRaises(NotImplementedError, lambda: box.__setitem__('', ''))
572 self.assertRaises(NotImplementedError, lambda: box.iterkeys())
573 self.assertRaises(NotImplementedError, lambda: box.keys())
574 self.assertRaises(NotImplementedError, lambda: box.itervalues().__next__())
575 self.assertRaises(NotImplementedError, lambda: box.__iter__().__next__())
576 self.assertRaises(NotImplementedError, lambda: box.values())
577 self.assertRaises(NotImplementedError, lambda: box.iteritems().__next__())
578 self.assertRaises(NotImplementedError, lambda: box.items())
579 self.assertRaises(NotImplementedError, lambda: box.get(''))
580 self.assertRaises(NotImplementedError, lambda: box.__getitem__(''))
581 self.assertRaises(NotImplementedError, lambda: box.get_message(''))
582 self.assertRaises(NotImplementedError, lambda: box.get_string(''))
583 self.assertRaises(NotImplementedError, lambda: box.get_bytes(''))
584 self.assertRaises(NotImplementedError, lambda: box.get_file(''))
585 self.assertRaises(NotImplementedError, lambda: '' in box)
586 self.assertRaises(NotImplementedError, lambda: box.__contains__(''))
587 self.assertRaises(NotImplementedError, lambda: box.__len__())
588 self.assertRaises(NotImplementedError, lambda: box.clear())
589 self.assertRaises(NotImplementedError, lambda: box.pop(''))
590 self.assertRaises(NotImplementedError, lambda: box.popitem())
591 self.assertRaises(NotImplementedError, lambda: box.update((('', ''),)))
592 self.assertRaises(NotImplementedError, lambda: box.flush())
593 self.assertRaises(NotImplementedError, lambda: box.lock())
594 self.assertRaises(NotImplementedError, lambda: box.unlock())
595 self.assertRaises(NotImplementedError, lambda: box.close())
596
597
598 class TestMaildir(TestMailbox, unittest.TestCase):
599
600 _factory = lambda self, path, factory=None: mailbox.Maildir(path, factory)
601
602 def setUp(self):
603 TestMailbox.setUp(self)
604 if (os.name == 'nt') or (sys.platform == 'cygwin'):
605 self._box.colon = '!'
606
607 def assertMailboxEmpty(self):
608 self.assertEqual(os.listdir(os.path.join(self._path, 'tmp')), [])
609
610 def test_add_MM(self):
611 # Add a MaildirMessage instance
612 msg = mailbox.MaildirMessage(self._template % 0)
613 msg.set_subdir('cur')
614 msg.set_info('foo')
615 key = self._box.add(msg)
616 self.assertTrue(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' %
617 (key, self._box.colon))))
618
619 def test_get_MM(self):
620 # Get a MaildirMessage instance
621 msg = mailbox.MaildirMessage(self._template % 0)
622 msg.set_subdir('cur')
623 msg.set_flags('RF')
624 key = self._box.add(msg)
625 msg_returned = self._box.get_message(key)
626 self.assertIsInstance(msg_returned, mailbox.MaildirMessage)
627 self.assertEqual(msg_returned.get_subdir(), 'cur')
628 self.assertEqual(msg_returned.get_flags(), 'FR')
629
630 def test_set_MM(self):
631 # Set with a MaildirMessage instance
632 msg0 = mailbox.MaildirMessage(self._template % 0)
633 msg0.set_flags('TP')
634 key = self._box.add(msg0)
635 msg_returned = self._box.get_message(key)
636 self.assertEqual(msg_returned.get_subdir(), 'new')
637 self.assertEqual(msg_returned.get_flags(), 'PT')
638 msg1 = mailbox.MaildirMessage(self._template % 1)
639 self._box[key] = msg1
640 msg_returned = self._box.get_message(key)
641 self.assertEqual(msg_returned.get_subdir(), 'new')
642 self.assertEqual(msg_returned.get_flags(), '')
643 self.assertEqual(msg_returned.get_payload(), '1\n')
644 msg2 = mailbox.MaildirMessage(self._template % 2)
645 msg2.set_info('2,S')
646 self._box[key] = msg2
647 self._box[key] = self._template % 3
648 msg_returned = self._box.get_message(key)
649 self.assertEqual(msg_returned.get_subdir(), 'new')
650 self.assertEqual(msg_returned.get_flags(), 'S')
651 self.assertEqual(msg_returned.get_payload(), '3\n')
652
653 def test_consistent_factory(self):
654 # Add a message.
655 msg = mailbox.MaildirMessage(self._template % 0)
656 msg.set_subdir('cur')
657 msg.set_flags('RF')
658 key = self._box.add(msg)
659
660 # Create new mailbox with
661 class FakeMessage(mailbox.MaildirMessage):
662 pass
663 box = mailbox.Maildir(self._path, factory=FakeMessage)
664 box.colon = self._box.colon
665 msg2 = box.get_message(key)
666 self.assertIsInstance(msg2, FakeMessage)
667
668 def test_initialize_new(self):
669 # Initialize a non-existent mailbox
670 self.tearDown()
671 self._box = mailbox.Maildir(self._path)
672 self._check_basics()
673 self._delete_recursively(self._path)
674 self._box = self._factory(self._path, factory=None)
675 self._check_basics()
676
677 def test_initialize_existing(self):
678 # Initialize an existing mailbox
679 self.tearDown()
680 for subdir in '', 'tmp', 'new', 'cur':
681 os.mkdir(os.path.normpath(os.path.join(self._path, subdir)))
682 self._box = mailbox.Maildir(self._path)
683 self._check_basics()
684
685 def test_filename_leading_dot(self):
686 self.tearDown()
687 for subdir in '', 'tmp', 'new', 'cur':
688 os.mkdir(os.path.normpath(os.path.join(self._path, subdir)))
689 for subdir in 'tmp', 'new', 'cur':
690 fname = os.path.join(self._path, subdir, '.foo' + subdir)
691 with open(fname, 'wb') as f:
692 f.write(b"@")
693 self._box = mailbox.Maildir(self._path)
694 self.assertNotIn('.footmp', self._box)
695 self.assertNotIn('.foonew', self._box)
696 self.assertNotIn('.foocur', self._box)
697 self.assertEqual(list(self._box.iterkeys()), [])
698
699 def _check_basics(self, factory=None):
700 # (Used by test_open_new() and test_open_existing().)
701 self.assertEqual(self._box._path, os.path.abspath(self._path))
702 self.assertEqual(self._box._factory, factory)
703 for subdir in '', 'tmp', 'new', 'cur':
704 path = os.path.join(self._path, subdir)
705 self.assertTrue(os.path.isdir(path), f"Not a directory: {path!r}")
706
707 def test_list_folders(self):
708 # List folders
709 self._box.add_folder('one')
710 self._box.add_folder('two')
711 self._box.add_folder('three')
712 self.assertEqual(len(self._box.list_folders()), 3)
713 self.assertEqual(set(self._box.list_folders()),
714 set(('one', 'two', 'three')))
715
716 def test_get_folder(self):
717 # Open folders
718 self._box.add_folder('foo.bar')
719 folder0 = self._box.get_folder('foo.bar')
720 folder0.add(self._template % 'bar')
721 self.assertTrue(os.path.isdir(os.path.join(self._path, '.foo.bar')))
722 folder1 = self._box.get_folder('foo.bar')
723 self.assertEqual(folder1.get_string(folder1.keys()[0]),
724 self._template % 'bar')
725
726 def test_add_and_remove_folders(self):
727 # Delete folders
728 self._box.add_folder('one')
729 self._box.add_folder('two')
730 self.assertEqual(len(self._box.list_folders()), 2)
731 self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
732 self._box.remove_folder('one')
733 self.assertEqual(len(self._box.list_folders()), 1)
734 self.assertEqual(set(self._box.list_folders()), set(('two',)))
735 self._box.add_folder('three')
736 self.assertEqual(len(self._box.list_folders()), 2)
737 self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
738 self._box.remove_folder('three')
739 self.assertEqual(len(self._box.list_folders()), 1)
740 self.assertEqual(set(self._box.list_folders()), set(('two',)))
741 self._box.remove_folder('two')
742 self.assertEqual(len(self._box.list_folders()), 0)
743 self.assertEqual(self._box.list_folders(), [])
744
745 def test_clean(self):
746 # Remove old files from 'tmp'
747 foo_path = os.path.join(self._path, 'tmp', 'foo')
748 bar_path = os.path.join(self._path, 'tmp', 'bar')
749 with open(foo_path, 'w', encoding='utf-8') as f:
750 f.write("@")
751 with open(bar_path, 'w', encoding='utf-8') as f:
752 f.write("@")
753 self._box.clean()
754 self.assertTrue(os.path.exists(foo_path))
755 self.assertTrue(os.path.exists(bar_path))
756 foo_stat = os.stat(foo_path)
757 os.utime(foo_path, (time.time() - 129600 - 2,
758 foo_stat.st_mtime))
759 self._box.clean()
760 self.assertFalse(os.path.exists(foo_path))
761 self.assertTrue(os.path.exists(bar_path))
762
763 def test_create_tmp(self, repetitions=10):
764 # Create files in tmp directory
765 hostname = socket.gethostname()
766 if '/' in hostname:
767 hostname = hostname.replace('/', r'\057')
768 if ':' in hostname:
769 hostname = hostname.replace(':', r'\072')
770 pid = os.getpid()
771 pattern = re.compile(r"(?P<time>\d+)\.M(?P<M>\d{1,6})P(?P<P>\d+)"
772 r"Q(?P<Q>\d+)\.(?P<host>[^:/]*)")
773 previous_groups = None
774 for x in range(repetitions):
775 tmp_file = self._box._create_tmp()
776 head, tail = os.path.split(tmp_file.name)
777 self.assertEqual(head, os.path.abspath(os.path.join(self._path,
778 "tmp")),
779 "File in wrong location: '%s'" % head)
780 match = pattern.match(tail)
781 self.assertIsNotNone(match, "Invalid file name: '%s'" % tail)
782 groups = match.groups()
783 if previous_groups is not None:
784 self.assertGreaterEqual(int(groups[0]), int(previous_groups[0]),
785 "Non-monotonic seconds: '%s' before '%s'" %
786 (previous_groups[0], groups[0]))
787 if int(groups[0]) == int(previous_groups[0]):
788 self.assertGreaterEqual(int(groups[1]), int(previous_groups[1]),
789 "Non-monotonic milliseconds: '%s' before '%s'" %
790 (previous_groups[1], groups[1]))
791 self.assertEqual(int(groups[2]), pid,
792 "Process ID mismatch: '%s' should be '%s'" %
793 (groups[2], pid))
794 self.assertEqual(int(groups[3]), int(previous_groups[3]) + 1,
795 "Non-sequential counter: '%s' before '%s'" %
796 (previous_groups[3], groups[3]))
797 self.assertEqual(groups[4], hostname,
798 "Host name mismatch: '%s' should be '%s'" %
799 (groups[4], hostname))
800 previous_groups = groups
801 tmp_file.write(_bytes_sample_message)
802 tmp_file.seek(0)
803 self.assertEqual(tmp_file.read(), _bytes_sample_message)
804 tmp_file.close()
805 file_count = len(os.listdir(os.path.join(self._path, "tmp")))
806 self.assertEqual(file_count, repetitions,
807 "Wrong file count: '%s' should be '%s'" %
808 (file_count, repetitions))
809
810 def test_refresh(self):
811 # Update the table of contents
812 self.assertEqual(self._box._toc, {})
813 key0 = self._box.add(self._template % 0)
814 key1 = self._box.add(self._template % 1)
815 self.assertEqual(self._box._toc, {})
816 self._box._refresh()
817 self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
818 key1: os.path.join('new', key1)})
819 key2 = self._box.add(self._template % 2)
820 self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
821 key1: os.path.join('new', key1)})
822 self._box._refresh()
823 self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
824 key1: os.path.join('new', key1),
825 key2: os.path.join('new', key2)})
826
827 def test_refresh_after_safety_period(self):
828 # Issue #13254: Call _refresh after the "file system safety
829 # period" of 2 seconds has passed; _toc should still be
830 # updated because this is the first call to _refresh.
831 key0 = self._box.add(self._template % 0)
832 key1 = self._box.add(self._template % 1)
833
834 self._box = self._factory(self._path)
835 self.assertEqual(self._box._toc, {})
836
837 # Emulate sleeping. Instead of sleeping for 2 seconds, use the
838 # skew factor to make _refresh think that the filesystem
839 # safety period has passed and re-reading the _toc is only
840 # required if mtimes differ.
841 self._box._skewfactor = -3
842
843 self._box._refresh()
844 self.assertEqual(sorted(self._box._toc.keys()), sorted([key0, key1]))
845
846 def test_lookup(self):
847 # Look up message subpaths in the TOC
848 self.assertRaises(KeyError, lambda: self._box._lookup('foo'))
849 key0 = self._box.add(self._template % 0)
850 self.assertEqual(self._box._lookup(key0), os.path.join('new', key0))
851 os.remove(os.path.join(self._path, 'new', key0))
852 self.assertEqual(self._box._toc, {key0: os.path.join('new', key0)})
853 # Be sure that the TOC is read back from disk (see issue #6896
854 # about bad mtime behaviour on some systems).
855 self._box.flush()
856 self.assertRaises(KeyError, lambda: self._box._lookup(key0))
857 self.assertEqual(self._box._toc, {})
858
859 def test_lock_unlock(self):
860 # Lock and unlock the mailbox. For Maildir, this does nothing.
861 self._box.lock()
862 self._box.unlock()
863
864 def test_get_info(self):
865 # Test getting message info from Maildir, not the message.
866 msg = mailbox.MaildirMessage(self._template % 0)
867 key = self._box.add(msg)
868 self.assertEqual(self._box.get_info(key), '')
869 msg.set_info('OurTestInfo')
870 self._box[key] = msg
871 self.assertEqual(self._box.get_info(key), 'OurTestInfo')
872
873 def test_set_info(self):
874 # Test setting message info from Maildir, not the message.
875 # This should immediately rename the message file.
876 msg = mailbox.MaildirMessage(self._template % 0)
877 key = self._box.add(msg)
878 def check_info(oldinfo, newinfo):
879 oldfilename = os.path.join(self._box._path, self._box._lookup(key))
880 newsubpath = self._box._lookup(key).split(self._box.colon)[0]
881 if newinfo:
882 newsubpath += self._box.colon + newinfo
883 newfilename = os.path.join(self._box._path, newsubpath)
884 # assert initial conditions
885 self.assertEqual(self._box.get_info(key), oldinfo)
886 if not oldinfo:
887 self.assertNotIn(self._box._lookup(key), self._box.colon)
888 self.assertTrue(os.path.exists(oldfilename))
889 if oldinfo != newinfo:
890 self.assertFalse(os.path.exists(newfilename))
891 # do the rename
892 self._box.set_info(key, newinfo)
893 # assert post conditions
894 if not newinfo:
895 self.assertNotIn(self._box._lookup(key), self._box.colon)
896 if oldinfo != newinfo:
897 self.assertFalse(os.path.exists(oldfilename))
898 self.assertTrue(os.path.exists(newfilename))
899 self.assertEqual(self._box.get_info(key), newinfo)
900 # none -> has info
901 check_info('', 'info1')
902 # has info -> same info
903 check_info('info1', 'info1')
904 # has info -> different info
905 check_info('info1', 'info2')
906 # has info -> none
907 check_info('info2', '')
908 # none -> none
909 check_info('', '')
910
911 def test_get_flags(self):
912 # Test getting message flags from Maildir, not the message.
913 msg = mailbox.MaildirMessage(self._template % 0)
914 key = self._box.add(msg)
915 self.assertEqual(self._box.get_flags(key), '')
916 msg.set_flags('T')
917 self._box[key] = msg
918 self.assertEqual(self._box.get_flags(key), 'T')
919
920 def test_set_flags(self):
921 msg = mailbox.MaildirMessage(self._template % 0)
922 key = self._box.add(msg)
923 self.assertEqual(self._box.get_flags(key), '')
924 self._box.set_flags(key, 'S')
925 self.assertEqual(self._box.get_flags(key), 'S')
926
927 def test_add_flag(self):
928 msg = mailbox.MaildirMessage(self._template % 0)
929 key = self._box.add(msg)
930 self.assertEqual(self._box.get_flags(key), '')
931 self._box.add_flag(key, 'B')
932 self.assertEqual(self._box.get_flags(key), 'B')
933 self._box.add_flag(key, 'B')
934 self.assertEqual(self._box.get_flags(key), 'B')
935 self._box.add_flag(key, 'AC')
936 self.assertEqual(self._box.get_flags(key), 'ABC')
937
938 def test_remove_flag(self):
939 msg = mailbox.MaildirMessage(self._template % 0)
940 key = self._box.add(msg)
941 self._box.set_flags(key, 'abc')
942 self.assertEqual(self._box.get_flags(key), 'abc')
943 self._box.remove_flag(key, 'b')
944 self.assertEqual(self._box.get_flags(key), 'ac')
945 self._box.remove_flag(key, 'b')
946 self.assertEqual(self._box.get_flags(key), 'ac')
947 self._box.remove_flag(key, 'ac')
948 self.assertEqual(self._box.get_flags(key), '')
949
950 def test_folder (self):
951 # Test for bug #1569790: verify that folders returned by .get_folder()
952 # use the same factory function.
953 def dummy_factory (s):
954 return None
955 box = self._factory(self._path, factory=dummy_factory)
956 folder = box.add_folder('folder1')
957 self.assertIs(folder._factory, dummy_factory)
958
959 folder1_alias = box.get_folder('folder1')
960 self.assertIs(folder1_alias._factory, dummy_factory)
961
962 def test_directory_in_folder (self):
963 # Test that mailboxes still work if there's a stray extra directory
964 # in a folder.
965 for i in range(10):
966 self._box.add(mailbox.Message(_sample_message))
967
968 # Create a stray directory
969 os.mkdir(os.path.join(self._path, 'cur', 'stray-dir'))
970
971 # Check that looping still works with the directory present.
972 for msg in self._box:
973 pass
974
975 @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
976 def test_file_permissions(self):
977 # Verify that message files are created without execute permissions
978 msg = mailbox.MaildirMessage(self._template % 0)
979 orig_umask = os.umask(0)
980 try:
981 key = self._box.add(msg)
982 finally:
983 os.umask(orig_umask)
984 path = os.path.join(self._path, self._box._lookup(key))
985 mode = os.stat(path).st_mode
986 self.assertFalse(mode & 0o111)
987
988 @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
989 def test_folder_file_perms(self):
990 # From bug #3228, we want to verify that the file created inside a Maildir
991 # subfolder isn't marked as executable.
992 orig_umask = os.umask(0)
993 try:
994 subfolder = self._box.add_folder('subfolder')
995 finally:
996 os.umask(orig_umask)
997
998 path = os.path.join(subfolder._path, 'maildirfolder')
999 st = os.stat(path)
1000 perms = st.st_mode
1001 self.assertFalse((perms & 0o111)) # Execute bits should all be off.
1002
1003 def test_reread(self):
1004 # Do an initial unconditional refresh
1005 self._box._refresh()
1006
1007 # Put the last modified times more than two seconds into the past
1008 # (because mtime may have a two second granularity)
1009 for subdir in ('cur', 'new'):
1010 os.utime(os.path.join(self._box._path, subdir),
1011 (time.time()-5,)*2)
1012
1013 # Because mtime has a two second granularity in worst case (FAT), a
1014 # refresh is done unconditionally if called for within
1015 # two-second-plus-a-bit of the last one, just in case the mbox has
1016 # changed; so now we have to wait for that interval to expire.
1017 #
1018 # Because this is a test, emulate sleeping. Instead of
1019 # sleeping for 2 seconds, use the skew factor to make _refresh
1020 # think that 2 seconds have passed and re-reading the _toc is
1021 # only required if mtimes differ.
1022 self._box._skewfactor = -3
1023
1024 # Re-reading causes the ._toc attribute to be assigned a new dictionary
1025 # object, so we'll check that the ._toc attribute isn't a different
1026 # object.
1027 orig_toc = self._box._toc
1028 def refreshed():
1029 return self._box._toc is not orig_toc
1030
1031 self._box._refresh()
1032 self.assertFalse(refreshed())
1033
1034 # Now, write something into cur and remove it. This changes
1035 # the mtime and should cause a re-read. Note that "sleep
1036 # emulation" is still in effect, as skewfactor is -3.
1037 filename = os.path.join(self._path, 'cur', 'stray-file')
1038 os_helper.create_empty_file(filename)
1039 os.unlink(filename)
1040 self._box._refresh()
1041 self.assertTrue(refreshed())
1042
1043
1044 class _TestSingleFile(TestMailbox):
1045 '''Common tests for single-file mailboxes'''
1046
1047 def test_add_doesnt_rewrite(self):
1048 # When only adding messages, flush() should not rewrite the
1049 # mailbox file. See issue #9559.
1050
1051 # Inode number changes if the contents are written to another
1052 # file which is then renamed over the original file. So we
1053 # must check that the inode number doesn't change.
1054 inode_before = os.stat(self._path).st_ino
1055
1056 self._box.add(self._template % 0)
1057 self._box.flush()
1058
1059 inode_after = os.stat(self._path).st_ino
1060 self.assertEqual(inode_before, inode_after)
1061
1062 # Make sure the message was really added
1063 self._box.close()
1064 self._box = self._factory(self._path)
1065 self.assertEqual(len(self._box), 1)
1066
1067 def test_permissions_after_flush(self):
1068 # See issue #5346
1069
1070 # Make the mailbox world writable. It's unlikely that the new
1071 # mailbox file would have these permissions after flush(),
1072 # because umask usually prevents it.
1073 mode = os.stat(self._path).st_mode | 0o666
1074 os.chmod(self._path, mode)
1075
1076 self._box.add(self._template % 0)
1077 i = self._box.add(self._template % 1)
1078 # Need to remove one message to make flush() create a new file
1079 self._box.remove(i)
1080 self._box.flush()
1081
1082 self.assertEqual(os.stat(self._path).st_mode, mode)
1083
1084 @unittest.skipUnless(hasattr(os, 'chown'), 'requires os.chown')
1085 def test_ownership_after_flush(self):
1086 # See issue gh-117467
1087
1088 pwd = import_helper.import_module('pwd')
1089 grp = import_helper.import_module('grp')
1090 st = os.stat(self._path)
1091
1092 for e in pwd.getpwall():
1093 if e.pw_uid != st.st_uid:
1094 other_uid = e.pw_uid
1095 break
1096 else:
1097 self.skipTest("test needs more than one user")
1098
1099 for e in grp.getgrall():
1100 if e.gr_gid != st.st_gid:
1101 other_gid = e.gr_gid
1102 break
1103 else:
1104 self.skipTest("test needs more than one group")
1105
1106 try:
1107 os.chown(self._path, other_uid, other_gid)
1108 except OSError:
1109 self.skipTest('test needs root privilege')
1110 # Change permissions as in test_permissions_after_flush.
1111 mode = st.st_mode | 0o666
1112 os.chmod(self._path, mode)
1113
1114 self._box.add(self._template % 0)
1115 i = self._box.add(self._template % 1)
1116 # Need to remove one message to make flush() create a new file
1117 self._box.remove(i)
1118 self._box.flush()
1119
1120 st = os.stat(self._path)
1121 self.assertEqual(st.st_uid, other_uid)
1122 self.assertEqual(st.st_gid, other_gid)
1123 self.assertEqual(st.st_mode, mode)
1124
1125
1126 class _TestMboxMMDF(_TestSingleFile):
1127
1128 def tearDown(self):
1129 super().tearDown()
1130 self._box.close()
1131 self._delete_recursively(self._path)
1132 for lock_remnant in glob.glob(glob.escape(self._path) + '.*'):
1133 os_helper.unlink(lock_remnant)
1134
1135 def assertMailboxEmpty(self):
1136 with open(self._path, 'rb') as f:
1137 self.assertEqual(f.readlines(), [])
1138
1139 def test_get_bytes_from(self):
1140 # Get bytes representations of messages with _unixfrom.
1141 unixfrom = 'From foo@bar blah\n'
1142 key0 = self._box.add(unixfrom + self._template % 0)
1143 key1 = self._box.add(unixfrom + _sample_message)
1144 self.assertEqual(self._box.get_bytes(key0, from_=False),
1145 (self._template % 0).encode('ascii'))
1146 self.assertEqual(self._box.get_bytes(key1, from_=False),
1147 _bytes_sample_message)
1148 self.assertEqual(self._box.get_bytes(key0, from_=True),
1149 (unixfrom + self._template % 0).encode('ascii'))
1150 self.assertEqual(self._box.get_bytes(key1, from_=True),
1151 unixfrom.encode('ascii') + _bytes_sample_message)
1152
1153 def test_get_string_from(self):
1154 # Get string representations of messages with _unixfrom.
1155 unixfrom = 'From foo@bar blah\n'
1156 key0 = self._box.add(unixfrom + self._template % 0)
1157 key1 = self._box.add(unixfrom + _sample_message)
1158 self.assertEqual(self._box.get_string(key0, from_=False),
1159 self._template % 0)
1160 self.assertEqual(self._box.get_string(key1, from_=False).split('\n'),
1161 _sample_message.split('\n'))
1162 self.assertEqual(self._box.get_string(key0, from_=True),
1163 unixfrom + self._template % 0)
1164 self.assertEqual(self._box.get_string(key1, from_=True).split('\n'),
1165 (unixfrom + _sample_message).split('\n'))
1166
1167 def test_add_from_string(self):
1168 # Add a string starting with 'From ' to the mailbox
1169 key = self._box.add('From foo@bar blah\nFrom: foo\n\n0\n')
1170 self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
1171 self.assertEqual(self._box[key].get_unixfrom(), 'From foo@bar blah')
1172 self.assertEqual(self._box[key].get_payload(), '0\n')
1173
1174 def test_add_from_bytes(self):
1175 # Add a byte string starting with 'From ' to the mailbox
1176 key = self._box.add(b'From foo@bar blah\nFrom: foo\n\n0\n')
1177 self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
1178 self.assertEqual(self._box[key].get_unixfrom(), 'From foo@bar blah')
1179 self.assertEqual(self._box[key].get_payload(), '0\n')
1180
1181 def test_add_mbox_or_mmdf_message(self):
1182 # Add an mboxMessage or MMDFMessage
1183 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1184 msg = class_('From foo@bar blah\nFrom: foo\n\n0\n')
1185 key = self._box.add(msg)
1186
1187 def test_open_close_open(self):
1188 # Open and inspect previously-created mailbox
1189 values = [self._template % i for i in range(3)]
1190 for value in values:
1191 self._box.add(value)
1192 self._box.close()
1193 mtime = os.path.getmtime(self._path)
1194 self._box = self._factory(self._path)
1195 self.assertEqual(len(self._box), 3)
1196 for key in self._box.iterkeys():
1197 self.assertIn(self._box.get_string(key), values)
1198 self._box.close()
1199 self.assertEqual(mtime, os.path.getmtime(self._path))
1200
1201 def test_add_and_close(self):
1202 # Verifying that closing a mailbox doesn't change added items
1203 self._box.add(_sample_message)
1204 for i in range(3):
1205 self._box.add(self._template % i)
1206 self._box.add(_sample_message)
1207 self._box._file.flush()
1208 self._box._file.seek(0)
1209 contents = self._box._file.read()
1210 self._box.close()
1211 with open(self._path, 'rb') as f:
1212 self.assertEqual(contents, f.read())
1213 self._box = self._factory(self._path)
1214
1215 @support.requires_fork()
1216 @unittest.skipUnless(hasattr(socket, 'socketpair'), "Test needs socketpair().")
1217 def test_lock_conflict(self):
1218 # Fork off a child process that will lock the mailbox temporarily,
1219 # unlock it and exit.
1220 c, p = socket.socketpair()
1221 self.addCleanup(c.close)
1222 self.addCleanup(p.close)
1223
1224 pid = os.fork()
1225 if pid == 0:
1226 # child
1227 try:
1228 # lock the mailbox, and signal the parent it can proceed
1229 self._box.lock()
1230 c.send(b'c')
1231
1232 # wait until the parent is done, and unlock the mailbox
1233 c.recv(1)
1234 self._box.unlock()
1235 finally:
1236 os._exit(0)
1237
1238 # In the parent, wait until the child signals it locked the mailbox.
1239 p.recv(1)
1240 try:
1241 self.assertRaises(mailbox.ExternalClashError,
1242 self._box.lock)
1243 finally:
1244 # Signal the child it can now release the lock and exit.
1245 p.send(b'p')
1246 # Wait for child to exit. Locking should now succeed.
1247 support.wait_process(pid, exitcode=0)
1248
1249 self._box.lock()
1250 self._box.unlock()
1251
1252 def test_relock(self):
1253 # Test case for bug #1575506: the mailbox class was locking the
1254 # wrong file object in its flush() method.
1255 msg = "Subject: sub\n\nbody\n"
1256 key1 = self._box.add(msg)
1257 self._box.flush()
1258 self._box.close()
1259
1260 self._box = self._factory(self._path)
1261 self._box.lock()
1262 key2 = self._box.add(msg)
1263 self._box.flush()
1264 self.assertTrue(self._box._locked)
1265 self._box.close()
1266
1267
1268 class TestMbox(_TestMboxMMDF, unittest.TestCase):
1269
1270 _factory = lambda self, path, factory=None: mailbox.mbox(path, factory)
1271
1272 @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
1273 def test_file_perms(self):
1274 # From bug #3228, we want to verify that the mailbox file isn't executable,
1275 # even if the umask is set to something that would leave executable bits set.
1276 # We only run this test on platforms that support umask.
1277 try:
1278 old_umask = os.umask(0o077)
1279 self._box.close()
1280 os.unlink(self._path)
1281 self._box = mailbox.mbox(self._path, create=True)
1282 self._box.add('')
1283 self._box.close()
1284 finally:
1285 os.umask(old_umask)
1286
1287 st = os.stat(self._path)
1288 perms = st.st_mode
1289 self.assertFalse((perms & 0o111)) # Execute bits should all be off.
1290
1291 def test_terminating_newline(self):
1292 message = email.message.Message()
1293 message['From'] = '[email protected]'
1294 message.set_payload('No newline at the end')
1295 i = self._box.add(message)
1296
1297 # A newline should have been appended to the payload
1298 message = self._box.get(i)
1299 self.assertEqual(message.get_payload(), 'No newline at the end\n')
1300
1301 def test_message_separator(self):
1302 # Check there's always a single blank line after each message
1303 self._box.add('From: foo\n\n0') # No newline at the end
1304 with open(self._path, encoding='utf-8') as f:
1305 data = f.read()
1306 self.assertEndsWith(data, '0\n\n')
1307
1308 self._box.add('From: foo\n\n0\n') # Newline at the end
1309 with open(self._path, encoding='utf-8') as f:
1310 data = f.read()
1311 self.assertEndsWith(data, '0\n\n')
1312
1313
1314 class TestMMDF(_TestMboxMMDF, unittest.TestCase):
1315
1316 _factory = lambda self, path, factory=None: mailbox.MMDF(path, factory)
1317
1318
1319 class TestMH(TestMailbox, unittest.TestCase):
1320
1321 _factory = lambda self, path, factory=None: mailbox.MH(path, factory)
1322
1323 def assertMailboxEmpty(self):
1324 self.assertEqual(os.listdir(self._path), ['.mh_sequences'])
1325
1326 def test_list_folders(self):
1327 # List folders
1328 self._box.add_folder('one')
1329 self._box.add_folder('two')
1330 self._box.add_folder('three')
1331 self.assertEqual(len(self._box.list_folders()), 3)
1332 self.assertEqual(set(self._box.list_folders()),
1333 set(('one', 'two', 'three')))
1334
1335 def test_get_folder(self):
1336 # Open folders
1337 def dummy_factory (s):
1338 return None
1339 self._box = self._factory(self._path, dummy_factory)
1340
1341 new_folder = self._box.add_folder('foo.bar')
1342 folder0 = self._box.get_folder('foo.bar')
1343 folder0.add(self._template % 'bar')
1344 self.assertTrue(os.path.isdir(os.path.join(self._path, 'foo.bar')))
1345 folder1 = self._box.get_folder('foo.bar')
1346 self.assertEqual(folder1.get_string(folder1.keys()[0]),
1347 self._template % 'bar')
1348
1349 # Test for bug #1569790: verify that folders returned by .get_folder()
1350 # use the same factory function.
1351 self.assertIs(new_folder._factory, self._box._factory)
1352 self.assertIs(folder0._factory, self._box._factory)
1353
1354 def test_add_and_remove_folders(self):
1355 # Delete folders
1356 self._box.add_folder('one')
1357 self._box.add_folder('two')
1358 self.assertEqual(len(self._box.list_folders()), 2)
1359 self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
1360 self._box.remove_folder('one')
1361 self.assertEqual(len(self._box.list_folders()), 1)
1362 self.assertEqual(set(self._box.list_folders()), set(('two',)))
1363 self._box.add_folder('three')
1364 self.assertEqual(len(self._box.list_folders()), 2)
1365 self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
1366 self._box.remove_folder('three')
1367 self.assertEqual(len(self._box.list_folders()), 1)
1368 self.assertEqual(set(self._box.list_folders()), set(('two',)))
1369 self._box.remove_folder('two')
1370 self.assertEqual(len(self._box.list_folders()), 0)
1371 self.assertEqual(self._box.list_folders(), [])
1372
1373 def test_sequences(self):
1374 # Get and set sequences
1375 self.assertEqual(self._box.get_sequences(), {})
1376 msg0 = mailbox.MHMessage(self._template % 0)
1377 msg0.add_sequence('foo')
1378 key0 = self._box.add(msg0)
1379 self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
1380 msg1 = mailbox.MHMessage(self._template % 1)
1381 msg1.set_sequences(['bar', 'replied', 'foo'])
1382 key1 = self._box.add(msg1)
1383 self.assertEqual(self._box.get_sequences(),
1384 {'foo':[key0, key1], 'bar':[key1], 'replied':[key1]})
1385 msg0.set_sequences(['flagged'])
1386 self._box[key0] = msg0
1387 self.assertEqual(self._box.get_sequences(),
1388 {'foo':[key1], 'bar':[key1], 'replied':[key1],
1389 'flagged':[key0]})
1390 self._box.remove(key1)
1391 self.assertEqual(self._box.get_sequences(), {'flagged':[key0]})
1392
1393 self._box.set_sequences({'foo':[key0]})
1394 self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
1395
1396 def test_no_dot_mh_sequences_file(self):
1397 path = os.path.join(self._path, 'foo.bar')
1398 os.mkdir(path)
1399 box = self._factory(path)
1400 self.assertEqual(os.listdir(path), [])
1401 self.assertEqual(box.get_sequences(), {})
1402 self.assertEqual(os.listdir(path), [])
1403 box.set_sequences({})
1404 self.assertEqual(os.listdir(path), ['.mh_sequences'])
1405
1406 def test_lock_unlock_no_dot_mh_sequences_file(self):
1407 path = os.path.join(self._path, 'foo.bar')
1408 os.mkdir(path)
1409 box = self._factory(path)
1410 self.assertEqual(os.listdir(path), [])
1411 box.lock()
1412 box.unlock()
1413 self.assertEqual(os.listdir(path), ['.mh_sequences'])
1414
1415 def test_issue2625(self):
1416 msg0 = mailbox.MHMessage(self._template % 0)
1417 msg0.add_sequence('foo')
1418 key0 = self._box.add(msg0)
1419 refmsg0 = self._box.get_message(key0)
1420
1421 def test_issue7627(self):
1422 msg0 = mailbox.MHMessage(self._template % 0)
1423 key0 = self._box.add(msg0)
1424 self._box.lock()
1425 self._box.remove(key0)
1426 self._box.unlock()
1427
1428 def test_pack(self):
1429 # Pack the contents of the mailbox
1430 msg0 = mailbox.MHMessage(self._template % 0)
1431 msg1 = mailbox.MHMessage(self._template % 1)
1432 msg2 = mailbox.MHMessage(self._template % 2)
1433 msg3 = mailbox.MHMessage(self._template % 3)
1434 msg0.set_sequences(['foo', 'unseen'])
1435 msg1.set_sequences(['foo'])
1436 msg2.set_sequences(['foo', 'flagged'])
1437 msg3.set_sequences(['foo', 'bar', 'replied'])
1438 key0 = self._box.add(msg0)
1439 key1 = self._box.add(msg1)
1440 key2 = self._box.add(msg2)
1441 key3 = self._box.add(msg3)
1442 self.assertEqual(self._box.get_sequences(),
1443 {'foo':[key0,key1,key2,key3], 'unseen':[key0],
1444 'flagged':[key2], 'bar':[key3], 'replied':[key3]})
1445 self._box.remove(key2)
1446 self.assertEqual(self._box.get_sequences(),
1447 {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3],
1448 'replied':[key3]})
1449 self._box.pack()
1450 self.assertEqual(self._box.keys(), [1, 2, 3])
1451 key0 = key0
1452 key1 = key0 + 1
1453 key2 = key1 + 1
1454 self.assertEqual(self._box.get_sequences(),
1455 {'foo':[1, 2, 3], 'unseen':[1], 'bar':[3], 'replied':[3]})
1456
1457 # Test case for packing while holding the mailbox locked.
1458 key0 = self._box.add(msg1)
1459 key1 = self._box.add(msg1)
1460 key2 = self._box.add(msg1)
1461 key3 = self._box.add(msg1)
1462
1463 self._box.remove(key0)
1464 self._box.remove(key2)
1465 self._box.lock()
1466 self._box.pack()
1467 self._box.unlock()
1468 self.assertEqual(self._box.get_sequences(),
1469 {'foo':[1, 2, 3, 4, 5],
1470 'unseen':[1], 'bar':[3], 'replied':[3]})
1471
1472 def _get_lock_path(self):
1473 return os.path.join(self._path, '.mh_sequences.lock')
1474
1475
1476 class TestBabyl(_TestSingleFile, unittest.TestCase):
1477
1478 _factory = lambda self, path, factory=None: mailbox.Babyl(path, factory)
1479
1480 def assertMailboxEmpty(self):
1481 with open(self._path, 'rb') as f:
1482 self.assertEqual(f.readlines(), [])
1483
1484 def tearDown(self):
1485 super().tearDown()
1486 self._box.close()
1487 self._delete_recursively(self._path)
1488 for lock_remnant in glob.glob(glob.escape(self._path) + '.*'):
1489 os_helper.unlink(lock_remnant)
1490
1491 def test_labels(self):
1492 # Get labels from the mailbox
1493 self.assertEqual(self._box.get_labels(), [])
1494 msg0 = mailbox.BabylMessage(self._template % 0)
1495 msg0.add_label('foo')
1496 key0 = self._box.add(msg0)
1497 self.assertEqual(self._box.get_labels(), ['foo'])
1498 msg1 = mailbox.BabylMessage(self._template % 1)
1499 msg1.set_labels(['bar', 'answered', 'foo'])
1500 key1 = self._box.add(msg1)
1501 self.assertEqual(set(self._box.get_labels()), set(['foo', 'bar']))
1502 msg0.set_labels(['blah', 'filed'])
1503 self._box[key0] = msg0
1504 self.assertEqual(set(self._box.get_labels()),
1505 set(['foo', 'bar', 'blah']))
1506 self._box.remove(key1)
1507 self.assertEqual(set(self._box.get_labels()), set(['blah']))
1508
1509
1510 class FakeFileLikeObject:
1511
1512 def __init__(self):
1513 self.closed = False
1514
1515 def close(self):
1516 self.closed = True
1517
1518
1519 class FakeMailBox(mailbox.Mailbox):
1520
1521 def __init__(self):
1522 mailbox.Mailbox.__init__(self, '', lambda file: None)
1523 self.files = [FakeFileLikeObject() for i in range(10)]
1524
1525 def get_file(self, key):
1526 return self.files[key]
1527
1528
1529 class TestFakeMailBox(unittest.TestCase):
1530
1531 def test_closing_fd(self):
1532 box = FakeMailBox()
1533 for i in range(10):
1534 self.assertFalse(box.files[i].closed)
1535 for i in range(10):
1536 box[i]
1537 for i in range(10):
1538 self.assertTrue(box.files[i].closed)
1539
1540
1541 class TestMessage(TestBase, unittest.TestCase):
1542
1543 _factory = mailbox.Message # Overridden by subclasses to reuse tests
1544
1545 def setUp(self):
1546 self._path = os_helper.TESTFN
1547
1548 def tearDown(self):
1549 self._delete_recursively(self._path)
1550
1551 def test_initialize_with_eMM(self):
1552 # Initialize based on email.message.Message instance
1553 eMM = email.message_from_string(_sample_message)
1554 msg = self._factory(eMM)
1555 self._post_initialize_hook(msg)
1556 self._check_sample(msg)
1557
1558 def test_initialize_with_string(self):
1559 # Initialize based on string
1560 msg = self._factory(_sample_message)
1561 self._post_initialize_hook(msg)
1562 self._check_sample(msg)
1563
1564 def test_initialize_with_file(self):
1565 # Initialize based on contents of file
1566 with open(self._path, 'w+', encoding='utf-8') as f:
1567 f.write(_sample_message)
1568 f.seek(0)
1569 msg = self._factory(f)
1570 self._post_initialize_hook(msg)
1571 self._check_sample(msg)
1572
1573 def test_initialize_with_binary_file(self):
1574 # Initialize based on contents of binary file
1575 with open(self._path, 'wb+') as f:
1576 f.write(_bytes_sample_message)
1577 f.seek(0)
1578 msg = self._factory(f)
1579 self._post_initialize_hook(msg)
1580 self._check_sample(msg)
1581
1582 def test_initialize_with_nothing(self):
1583 # Initialize without arguments
1584 msg = self._factory()
1585 self._post_initialize_hook(msg)
1586 self.assertIsInstance(msg, email.message.Message)
1587 self.assertIsInstance(msg, mailbox.Message)
1588 self.assertIsInstance(msg, self._factory)
1589 self.assertEqual(msg.keys(), [])
1590 self.assertFalse(msg.is_multipart())
1591 self.assertIsNone(msg.get_payload())
1592
1593 def test_initialize_incorrectly(self):
1594 # Initialize with invalid argument
1595 self.assertRaises(TypeError, lambda: self._factory(object()))
1596
1597 def test_all_eMM_attributes_exist(self):
1598 # Issue 12537
1599 eMM = email.message_from_string(_sample_message)
1600 msg = self._factory(_sample_message)
1601 for attr in eMM.__dict__:
1602 self.assertIn(attr, msg.__dict__,
1603 '{} attribute does not exist'.format(attr))
1604
1605 def test_become_message(self):
1606 # Take on the state of another message
1607 eMM = email.message_from_string(_sample_message)
1608 msg = self._factory()
1609 msg._become_message(eMM)
1610 self._check_sample(msg)
1611
1612 def test_explain_to(self):
1613 # Copy self's format-specific data to other message formats.
1614 # This test is superficial; better ones are in TestMessageConversion.
1615 msg = self._factory()
1616 for class_ in self.all_mailbox_types:
1617 other_msg = class_()
1618 msg._explain_to(other_msg)
1619 other_msg = email.message.Message()
1620 self.assertRaises(TypeError, lambda: msg._explain_to(other_msg))
1621
1622 def _post_initialize_hook(self, msg):
1623 # Overridden by subclasses to check extra things after initialization
1624 pass
1625
1626
1627 class TestMaildirMessage(TestMessage, unittest.TestCase):
1628
1629 _factory = mailbox.MaildirMessage
1630
1631 def _post_initialize_hook(self, msg):
1632 self.assertEqual(msg._subdir, 'new')
1633 self.assertEqual(msg._info, '')
1634
1635 def test_subdir(self):
1636 # Use get_subdir() and set_subdir()
1637 msg = mailbox.MaildirMessage(_sample_message)
1638 self.assertEqual(msg.get_subdir(), 'new')
1639 msg.set_subdir('cur')
1640 self.assertEqual(msg.get_subdir(), 'cur')
1641 msg.set_subdir('new')
1642 self.assertEqual(msg.get_subdir(), 'new')
1643 self.assertRaises(ValueError, lambda: msg.set_subdir('tmp'))
1644 self.assertEqual(msg.get_subdir(), 'new')
1645 msg.set_subdir('new')
1646 self.assertEqual(msg.get_subdir(), 'new')
1647 self._check_sample(msg)
1648
1649 def test_flags(self):
1650 # Use get_flags(), set_flags(), add_flag(), remove_flag()
1651 msg = mailbox.MaildirMessage(_sample_message)
1652 self.assertEqual(msg.get_flags(), '')
1653 self.assertEqual(msg.get_subdir(), 'new')
1654 msg.set_flags('F')
1655 self.assertEqual(msg.get_subdir(), 'new')
1656 self.assertEqual(msg.get_flags(), 'F')
1657 msg.set_flags('SDTP')
1658 self.assertEqual(msg.get_flags(), 'DPST')
1659 msg.add_flag('FT')
1660 self.assertEqual(msg.get_flags(), 'DFPST')
1661 msg.remove_flag('TDRP')
1662 self.assertEqual(msg.get_flags(), 'FS')
1663 self.assertEqual(msg.get_subdir(), 'new')
1664 self._check_sample(msg)
1665
1666 def test_date(self):
1667 # Use get_date() and set_date()
1668 msg = mailbox.MaildirMessage(_sample_message)
1669 self.assertLess(abs(msg.get_date() - time.time()), 60)
1670 msg.set_date(0.0)
1671 self.assertEqual(msg.get_date(), 0.0)
1672
1673 def test_info(self):
1674 # Use get_info() and set_info()
1675 msg = mailbox.MaildirMessage(_sample_message)
1676 self.assertEqual(msg.get_info(), '')
1677 msg.set_info('1,foo=bar')
1678 self.assertEqual(msg.get_info(), '1,foo=bar')
1679 self.assertRaises(TypeError, lambda: msg.set_info(None))
1680 self._check_sample(msg)
1681
1682 def test_info_and_flags(self):
1683 # Test interaction of info and flag methods
1684 msg = mailbox.MaildirMessage(_sample_message)
1685 self.assertEqual(msg.get_info(), '')
1686 msg.set_flags('SF')
1687 self.assertEqual(msg.get_flags(), 'FS')
1688 self.assertEqual(msg.get_info(), '2,FS')
1689 msg.set_info('1,')
1690 self.assertEqual(msg.get_flags(), '')
1691 self.assertEqual(msg.get_info(), '1,')
1692 msg.remove_flag('RPT')
1693 self.assertEqual(msg.get_flags(), '')
1694 self.assertEqual(msg.get_info(), '1,')
1695 msg.add_flag('D')
1696 self.assertEqual(msg.get_flags(), 'D')
1697 self.assertEqual(msg.get_info(), '2,D')
1698 self._check_sample(msg)
1699
1700
1701 class _TestMboxMMDFMessage:
1702
1703 _factory = mailbox._mboxMMDFMessage
1704
1705 def _post_initialize_hook(self, msg):
1706 self._check_from(msg)
1707
1708 def test_initialize_with_unixfrom(self):
1709 # Initialize with a message that already has a _unixfrom attribute
1710 msg = mailbox.Message(_sample_message)
1711 msg.set_unixfrom('From foo@bar blah')
1712 msg = mailbox.mboxMessage(msg)
1713 self.assertEqual(msg.get_from(), 'foo@bar blah')
1714 self.assertEqual(msg.get_unixfrom(), 'From foo@bar blah')
1715
1716 def test_from(self):
1717 # Get and set "From " line
1718 msg = mailbox.mboxMessage(_sample_message)
1719 self._check_from(msg)
1720 self.assertIsNone(msg.get_unixfrom())
1721 msg.set_from('foo bar')
1722 self.assertEqual(msg.get_from(), 'foo bar')
1723 self.assertIsNone(msg.get_unixfrom())
1724 msg.set_from('foo@bar', True)
1725 self._check_from(msg, 'foo@bar')
1726 self.assertIsNone(msg.get_unixfrom())
1727 msg.set_from('blah@temp', time.localtime())
1728 self._check_from(msg, 'blah@temp')
1729 self.assertIsNone(msg.get_unixfrom())
1730
1731 def test_flags(self):
1732 # Use get_flags(), set_flags(), add_flag(), remove_flag()
1733 msg = mailbox.mboxMessage(_sample_message)
1734 self.assertEqual(msg.get_flags(), '')
1735 msg.set_flags('F')
1736 self.assertEqual(msg.get_flags(), 'F')
1737 msg.set_flags('XODR')
1738 self.assertEqual(msg.get_flags(), 'RODX')
1739 msg.add_flag('FA')
1740 self.assertEqual(msg.get_flags(), 'RODFAX')
1741 msg.remove_flag('FDXA')
1742 self.assertEqual(msg.get_flags(), 'RO')
1743 self._check_sample(msg)
1744
1745 def _check_from(self, msg, sender=None):
1746 # Check contents of "From " line
1747 if sender is None:
1748 sender = "MAILER-DAEMON"
1749 self.assertIsNotNone(re.match(
1750 sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:\d{2} \d{4}",
1751 msg.get_from()))
1752
1753
1754 class TestMboxMessage(_TestMboxMMDFMessage, TestMessage):
1755
1756 _factory = mailbox.mboxMessage
1757
1758
1759 class TestMHMessage(TestMessage, unittest.TestCase):
1760
1761 _factory = mailbox.MHMessage
1762
1763 def _post_initialize_hook(self, msg):
1764 self.assertEqual(msg._sequences, [])
1765
1766 def test_sequences(self):
1767 # Get, set, join, and leave sequences
1768 msg = mailbox.MHMessage(_sample_message)
1769 self.assertEqual(msg.get_sequences(), [])
1770 msg.set_sequences(['foobar'])
1771 self.assertEqual(msg.get_sequences(), ['foobar'])
1772 msg.set_sequences([])
1773 self.assertEqual(msg.get_sequences(), [])
1774 msg.add_sequence('unseen')
1775 self.assertEqual(msg.get_sequences(), ['unseen'])
1776 msg.add_sequence('flagged')
1777 self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
1778 msg.add_sequence('flagged')
1779 self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
1780 msg.remove_sequence('unseen')
1781 self.assertEqual(msg.get_sequences(), ['flagged'])
1782 msg.add_sequence('foobar')
1783 self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
1784 msg.remove_sequence('replied')
1785 self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
1786 msg.set_sequences(['foobar', 'replied'])
1787 self.assertEqual(msg.get_sequences(), ['foobar', 'replied'])
1788
1789
1790 class TestBabylMessage(TestMessage, unittest.TestCase):
1791
1792 _factory = mailbox.BabylMessage
1793
1794 def _post_initialize_hook(self, msg):
1795 self.assertEqual(msg._labels, [])
1796
1797 def test_labels(self):
1798 # Get, set, join, and leave labels
1799 msg = mailbox.BabylMessage(_sample_message)
1800 self.assertEqual(msg.get_labels(), [])
1801 msg.set_labels(['foobar'])
1802 self.assertEqual(msg.get_labels(), ['foobar'])
1803 msg.set_labels([])
1804 self.assertEqual(msg.get_labels(), [])
1805 msg.add_label('filed')
1806 self.assertEqual(msg.get_labels(), ['filed'])
1807 msg.add_label('resent')
1808 self.assertEqual(msg.get_labels(), ['filed', 'resent'])
1809 msg.add_label('resent')
1810 self.assertEqual(msg.get_labels(), ['filed', 'resent'])
1811 msg.remove_label('filed')
1812 self.assertEqual(msg.get_labels(), ['resent'])
1813 msg.add_label('foobar')
1814 self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
1815 msg.remove_label('unseen')
1816 self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
1817 msg.set_labels(['foobar', 'answered'])
1818 self.assertEqual(msg.get_labels(), ['foobar', 'answered'])
1819
1820 def test_visible(self):
1821 # Get, set, and update visible headers
1822 msg = mailbox.BabylMessage(_sample_message)
1823 visible = msg.get_visible()
1824 self.assertEqual(visible.keys(), [])
1825 self.assertIsNone(visible.get_payload())
1826 visible['User-Agent'] = 'FooBar 1.0'
1827 visible['X-Whatever'] = 'Blah'
1828 self.assertEqual(msg.get_visible().keys(), [])
1829 msg.set_visible(visible)
1830 visible = msg.get_visible()
1831 self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
1832 self.assertEqual(visible['User-Agent'], 'FooBar 1.0')
1833 self.assertEqual(visible['X-Whatever'], 'Blah')
1834 self.assertIsNone(visible.get_payload())
1835 msg.update_visible()
1836 self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
1837 self.assertIsNone(visible.get_payload())
1838 visible = msg.get_visible()
1839 self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To',
1840 'Subject'])
1841 for header in ('User-Agent', 'Date', 'From', 'To', 'Subject'):
1842 self.assertEqual(visible[header], msg[header])
1843
1844
1845 class TestMMDFMessage(_TestMboxMMDFMessage, TestMessage):
1846
1847 _factory = mailbox.MMDFMessage
1848
1849
1850 class TestMessageConversion(TestBase, unittest.TestCase):
1851
1852 def test_plain_to_x(self):
1853 # Convert Message to all formats
1854 for class_ in self.all_mailbox_types:
1855 msg_plain = mailbox.Message(_sample_message)
1856 msg = class_(msg_plain)
1857 self._check_sample(msg)
1858
1859 def test_x_to_plain(self):
1860 # Convert all formats to Message
1861 for class_ in self.all_mailbox_types:
1862 msg = class_(_sample_message)
1863 msg_plain = mailbox.Message(msg)
1864 self._check_sample(msg_plain)
1865
1866 def test_x_from_bytes(self):
1867 # Convert all formats to Message
1868 for class_ in self.all_mailbox_types:
1869 msg = class_(_bytes_sample_message)
1870 self._check_sample(msg)
1871
1872 def test_x_to_invalid(self):
1873 # Convert all formats to an invalid format
1874 for class_ in self.all_mailbox_types:
1875 self.assertRaises(TypeError, lambda: class_(False))
1876
1877 def test_type_specific_attributes_removed_on_conversion(self):
1878 reference = {class_: class_(_sample_message).__dict__
1879 for class_ in self.all_mailbox_types}
1880 for class1 in self.all_mailbox_types:
1881 for class2 in self.all_mailbox_types:
1882 if class1 is class2:
1883 continue
1884 source = class1(_sample_message)
1885 target = class2(source)
1886 type_specific = [a for a in reference[class1]
1887 if a not in reference[class2]]
1888 for attr in type_specific:
1889 self.assertNotIn(attr, target.__dict__,
1890 "while converting {} to {}".format(class1, class2))
1891
1892 def test_maildir_to_maildir(self):
1893 # Convert MaildirMessage to MaildirMessage
1894 msg_maildir = mailbox.MaildirMessage(_sample_message)
1895 msg_maildir.set_flags('DFPRST')
1896 msg_maildir.set_subdir('cur')
1897 date = msg_maildir.get_date()
1898 msg = mailbox.MaildirMessage(msg_maildir)
1899 self._check_sample(msg)
1900 self.assertEqual(msg.get_flags(), 'DFPRST')
1901 self.assertEqual(msg.get_subdir(), 'cur')
1902 self.assertEqual(msg.get_date(), date)
1903
1904 def test_maildir_to_mboxmmdf(self):
1905 # Convert MaildirMessage to mboxmessage and MMDFMessage
1906 pairs = (('D', ''), ('F', 'F'), ('P', ''), ('R', 'A'), ('S', 'R'),
1907 ('T', 'D'), ('DFPRST', 'RDFA'))
1908 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1909 msg_maildir = mailbox.MaildirMessage(_sample_message)
1910 msg_maildir.set_date(0.0)
1911 for setting, result in pairs:
1912 msg_maildir.set_flags(setting)
1913 msg = class_(msg_maildir)
1914 self.assertEqual(msg.get_flags(), result)
1915 self.assertEqual(msg.get_from(), 'MAILER-DAEMON %s' %
1916 time.asctime(time.gmtime(0.0)))
1917 self.assertIsNone(msg.get_unixfrom())
1918 msg_maildir.set_subdir('cur')
1919 self.assertEqual(class_(msg_maildir).get_flags(), 'RODFA')
1920
1921 def test_maildir_to_mh(self):
1922 # Convert MaildirMessage to MHMessage
1923 msg_maildir = mailbox.MaildirMessage(_sample_message)
1924 pairs = (('D', ['unseen']), ('F', ['unseen', 'flagged']),
1925 ('P', ['unseen']), ('R', ['unseen', 'replied']), ('S', []),
1926 ('T', ['unseen']), ('DFPRST', ['replied', 'flagged']))
1927 for setting, result in pairs:
1928 msg_maildir.set_flags(setting)
1929 self.assertEqual(mailbox.MHMessage(msg_maildir).get_sequences(),
1930 result)
1931
1932 def test_maildir_to_babyl(self):
1933 # Convert MaildirMessage to Babyl
1934 msg_maildir = mailbox.MaildirMessage(_sample_message)
1935 pairs = (('D', ['unseen']), ('F', ['unseen']),
1936 ('P', ['unseen', 'forwarded']), ('R', ['unseen', 'answered']),
1937 ('S', []), ('T', ['unseen', 'deleted']),
1938 ('DFPRST', ['deleted', 'answered', 'forwarded']))
1939 for setting, result in pairs:
1940 msg_maildir.set_flags(setting)
1941 self.assertEqual(mailbox.BabylMessage(msg_maildir).get_labels(),
1942 result)
1943
1944 def test_mboxmmdf_to_maildir(self):
1945 # Convert mboxMessage and MMDFMessage to MaildirMessage
1946 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1947 msg_mboxMMDF = class_(_sample_message)
1948 msg_mboxMMDF.set_from('foo@bar', time.gmtime(0.0))
1949 pairs = (('R', 'S'), ('O', ''), ('D', 'T'), ('F', 'F'), ('A', 'R'),
1950 ('RODFA', 'FRST'))
1951 for setting, result in pairs:
1952 msg_mboxMMDF.set_flags(setting)
1953 msg = mailbox.MaildirMessage(msg_mboxMMDF)
1954 self.assertEqual(msg.get_flags(), result)
1955 self.assertEqual(msg.get_date(), 0.0)
1956 msg_mboxMMDF.set_flags('O')
1957 self.assertEqual(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir(),
1958 'cur')
1959
1960 def test_mboxmmdf_to_mboxmmdf(self):
1961 # Convert mboxMessage and MMDFMessage to mboxMessage and MMDFMessage
1962 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1963 msg_mboxMMDF = class_(_sample_message)
1964 msg_mboxMMDF.set_flags('RODFA')
1965 msg_mboxMMDF.set_from('foo@bar')
1966 self.assertIsNone(msg_mboxMMDF.get_unixfrom())
1967 for class2_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1968 msg2 = class2_(msg_mboxMMDF)
1969 self.assertEqual(msg2.get_flags(), 'RODFA')
1970 self.assertEqual(msg2.get_from(), 'foo@bar')
1971 self.assertIsNone(msg2.get_unixfrom())
1972
1973 def test_mboxmmdf_to_mh(self):
1974 # Convert mboxMessage and MMDFMessage to MHMessage
1975 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1976 msg_mboxMMDF = class_(_sample_message)
1977 pairs = (('R', []), ('O', ['unseen']), ('D', ['unseen']),
1978 ('F', ['unseen', 'flagged']),
1979 ('A', ['unseen', 'replied']),
1980 ('RODFA', ['replied', 'flagged']))
1981 for setting, result in pairs:
1982 msg_mboxMMDF.set_flags(setting)
1983 self.assertEqual(mailbox.MHMessage(msg_mboxMMDF).get_sequences(),
1984 result)
1985
1986 def test_mboxmmdf_to_babyl(self):
1987 # Convert mboxMessage and MMDFMessage to BabylMessage
1988 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
1989 msg = class_(_sample_message)
1990 pairs = (('R', []), ('O', ['unseen']),
1991 ('D', ['unseen', 'deleted']), ('F', ['unseen']),
1992 ('A', ['unseen', 'answered']),
1993 ('RODFA', ['deleted', 'answered']))
1994 for setting, result in pairs:
1995 msg.set_flags(setting)
1996 self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
1997
1998 def test_mh_to_maildir(self):
1999 # Convert MHMessage to MaildirMessage
2000 pairs = (('unseen', ''), ('replied', 'RS'), ('flagged', 'FS'))
2001 for setting, result in pairs:
2002 msg = mailbox.MHMessage(_sample_message)
2003 msg.add_sequence(setting)
2004 self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
2005 self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
2006 msg = mailbox.MHMessage(_sample_message)
2007 msg.add_sequence('unseen')
2008 msg.add_sequence('replied')
2009 msg.add_sequence('flagged')
2010 self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'FR')
2011 self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
2012
2013 def test_mh_to_mboxmmdf(self):
2014 # Convert MHMessage to mboxMessage and MMDFMessage
2015 pairs = (('unseen', 'O'), ('replied', 'ROA'), ('flagged', 'ROF'))
2016 for setting, result in pairs:
2017 msg = mailbox.MHMessage(_sample_message)
2018 msg.add_sequence(setting)
2019 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
2020 self.assertEqual(class_(msg).get_flags(), result)
2021 msg = mailbox.MHMessage(_sample_message)
2022 msg.add_sequence('unseen')
2023 msg.add_sequence('replied')
2024 msg.add_sequence('flagged')
2025 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
2026 self.assertEqual(class_(msg).get_flags(), 'OFA')
2027
2028 def test_mh_to_mh(self):
2029 # Convert MHMessage to MHMessage
2030 msg = mailbox.MHMessage(_sample_message)
2031 msg.add_sequence('unseen')
2032 msg.add_sequence('replied')
2033 msg.add_sequence('flagged')
2034 self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
2035 ['unseen', 'replied', 'flagged'])
2036
2037 def test_mh_to_babyl(self):
2038 # Convert MHMessage to BabylMessage
2039 pairs = (('unseen', ['unseen']), ('replied', ['answered']),
2040 ('flagged', []))
2041 for setting, result in pairs:
2042 msg = mailbox.MHMessage(_sample_message)
2043 msg.add_sequence(setting)
2044 self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
2045 msg = mailbox.MHMessage(_sample_message)
2046 msg.add_sequence('unseen')
2047 msg.add_sequence('replied')
2048 msg.add_sequence('flagged')
2049 self.assertEqual(mailbox.BabylMessage(msg).get_labels(),
2050 ['unseen', 'answered'])
2051
2052 def test_babyl_to_maildir(self):
2053 # Convert BabylMessage to MaildirMessage
2054 pairs = (('unseen', ''), ('deleted', 'ST'), ('filed', 'S'),
2055 ('answered', 'RS'), ('forwarded', 'PS'), ('edited', 'S'),
2056 ('resent', 'PS'))
2057 for setting, result in pairs:
2058 msg = mailbox.BabylMessage(_sample_message)
2059 msg.add_label(setting)
2060 self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
2061 self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
2062 msg = mailbox.BabylMessage(_sample_message)
2063 for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
2064 'edited', 'resent'):
2065 msg.add_label(label)
2066 self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'PRT')
2067 self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
2068
2069 def test_babyl_to_mboxmmdf(self):
2070 # Convert BabylMessage to mboxMessage and MMDFMessage
2071 pairs = (('unseen', 'O'), ('deleted', 'ROD'), ('filed', 'RO'),
2072 ('answered', 'ROA'), ('forwarded', 'RO'), ('edited', 'RO'),
2073 ('resent', 'RO'))
2074 for setting, result in pairs:
2075 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
2076 msg = mailbox.BabylMessage(_sample_message)
2077 msg.add_label(setting)
2078 self.assertEqual(class_(msg).get_flags(), result)
2079 msg = mailbox.BabylMessage(_sample_message)
2080 for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
2081 'edited', 'resent'):
2082 msg.add_label(label)
2083 for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
2084 self.assertEqual(class_(msg).get_flags(), 'ODA')
2085
2086 def test_babyl_to_mh(self):
2087 # Convert BabylMessage to MHMessage
2088 pairs = (('unseen', ['unseen']), ('deleted', []), ('filed', []),
2089 ('answered', ['replied']), ('forwarded', []), ('edited', []),
2090 ('resent', []))
2091 for setting, result in pairs:
2092 msg = mailbox.BabylMessage(_sample_message)
2093 msg.add_label(setting)
2094 self.assertEqual(mailbox.MHMessage(msg).get_sequences(), result)
2095 msg = mailbox.BabylMessage(_sample_message)
2096 for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
2097 'edited', 'resent'):
2098 msg.add_label(label)
2099 self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
2100 ['unseen', 'replied'])
2101
2102 def test_babyl_to_babyl(self):
2103 # Convert BabylMessage to BabylMessage
2104 msg = mailbox.BabylMessage(_sample_message)
2105 msg.update_visible()
2106 for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
2107 'edited', 'resent'):
2108 msg.add_label(label)
2109 msg2 = mailbox.BabylMessage(msg)
2110 self.assertEqual(msg2.get_labels(), ['unseen', 'deleted', 'filed',
2111 'answered', 'forwarded', 'edited',
2112 'resent'])
2113 self.assertEqual(msg.get_visible().keys(), msg2.get_visible().keys())
2114 for key in msg.get_visible().keys():
2115 self.assertEqual(msg.get_visible()[key], msg2.get_visible()[key])
2116
2117
2118 class TestProxyFileBase(TestBase):
2119
2120 def _test_read(self, proxy):
2121 # Read by byte
2122 proxy.seek(0)
2123 self.assertEqual(proxy.read(), b'bar')
2124 proxy.seek(1)
2125 self.assertEqual(proxy.read(), b'ar')
2126 proxy.seek(0)
2127 self.assertEqual(proxy.read(2), b'ba')
2128 proxy.seek(1)
2129 self.assertEqual(proxy.read(-1), b'ar')
2130 proxy.seek(2)
2131 self.assertEqual(proxy.read(1000), b'r')
2132
2133 def _test_readline(self, proxy):
2134 # Read by line
2135 linesep = os.linesep.encode()
2136 proxy.seek(0)
2137 self.assertEqual(proxy.readline(), b'foo' + linesep)
2138 self.assertEqual(proxy.readline(), b'bar' + linesep)
2139 self.assertEqual(proxy.readline(), b'fred' + linesep)
2140 self.assertEqual(proxy.readline(), b'bob')
2141 proxy.seek(2)
2142 self.assertEqual(proxy.readline(), b'o' + linesep)
2143 proxy.seek(6 + 2 * len(os.linesep))
2144 self.assertEqual(proxy.readline(), b'fred' + linesep)
2145 proxy.seek(6 + 2 * len(os.linesep))
2146 self.assertEqual(proxy.readline(2), b'fr')
2147 self.assertEqual(proxy.readline(-10), b'ed' + linesep)
2148
2149 def _test_readlines(self, proxy):
2150 # Read multiple lines
2151 linesep = os.linesep.encode()
2152 proxy.seek(0)
2153 self.assertEqual(proxy.readlines(), [b'foo' + linesep,
2154 b'bar' + linesep,
2155 b'fred' + linesep, b'bob'])
2156 proxy.seek(0)
2157 self.assertEqual(proxy.readlines(2), [b'foo' + linesep])
2158 proxy.seek(3 + len(linesep))
2159 self.assertEqual(proxy.readlines(4 + len(linesep)),
2160 [b'bar' + linesep, b'fred' + linesep])
2161 proxy.seek(3)
2162 self.assertEqual(proxy.readlines(1000), [linesep, b'bar' + linesep,
2163 b'fred' + linesep, b'bob'])
2164
2165 def _test_iteration(self, proxy):
2166 # Iterate by line
2167 linesep = os.linesep.encode()
2168 proxy.seek(0)
2169 iterator = iter(proxy)
2170 self.assertEqual(next(iterator), b'foo' + linesep)
2171 self.assertEqual(next(iterator), b'bar' + linesep)
2172 self.assertEqual(next(iterator), b'fred' + linesep)
2173 self.assertEqual(next(iterator), b'bob')
2174 self.assertRaises(StopIteration, next, iterator)
2175
2176 def _test_seek_and_tell(self, proxy):
2177 # Seek and use tell to check position
2178 linesep = os.linesep.encode()
2179 proxy.seek(3)
2180 self.assertEqual(proxy.tell(), 3)
2181 self.assertEqual(proxy.read(len(linesep)), linesep)
2182 proxy.seek(2, 1)
2183 self.assertEqual(proxy.read(1 + len(linesep)), b'r' + linesep)
2184 proxy.seek(-3 - len(linesep), 2)
2185 self.assertEqual(proxy.read(3), b'bar')
2186 proxy.seek(2, 0)
2187 self.assertEqual(proxy.read(), b'o' + linesep + b'bar' + linesep)
2188 proxy.seek(100)
2189 self.assertFalse(proxy.read())
2190
2191 def _test_close(self, proxy):
2192 # Close a file
2193 self.assertFalse(proxy.closed)
2194 proxy.close()
2195 self.assertTrue(proxy.closed)
2196 # Issue 11700 subsequent closes should be a no-op.
2197 proxy.close()
2198 self.assertTrue(proxy.closed)
2199
2200
2201 class TestProxyFile(TestProxyFileBase, unittest.TestCase):
2202
2203 def setUp(self):
2204 self._path = os_helper.TESTFN
2205 self._file = open(self._path, 'wb+')
2206
2207 def tearDown(self):
2208 self._file.close()
2209 self._delete_recursively(self._path)
2210
2211 def test_initialize(self):
2212 # Initialize and check position
2213 self._file.write(b'foo')
2214 pos = self._file.tell()
2215 proxy0 = mailbox._ProxyFile(self._file)
2216 self.assertEqual(proxy0.tell(), pos)
2217 self.assertEqual(self._file.tell(), pos)
2218 proxy1 = mailbox._ProxyFile(self._file, 0)
2219 self.assertEqual(proxy1.tell(), 0)
2220 self.assertEqual(self._file.tell(), pos)
2221
2222 def test_read(self):
2223 self._file.write(b'bar')
2224 self._test_read(mailbox._ProxyFile(self._file))
2225
2226 def test_readline(self):
2227 self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
2228 os.linesep), 'ascii'))
2229 self._test_readline(mailbox._ProxyFile(self._file))
2230
2231 def test_readlines(self):
2232 self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
2233 os.linesep), 'ascii'))
2234 self._test_readlines(mailbox._ProxyFile(self._file))
2235
2236 def test_iteration(self):
2237 self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
2238 os.linesep), 'ascii'))
2239 self._test_iteration(mailbox._ProxyFile(self._file))
2240
2241 def test_seek_and_tell(self):
2242 self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
2243 self._test_seek_and_tell(mailbox._ProxyFile(self._file))
2244
2245 def test_close(self):
2246 self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
2247 self._test_close(mailbox._ProxyFile(self._file))
2248
2249
2250 class TestPartialFile(TestProxyFileBase, unittest.TestCase):
2251
2252 def setUp(self):
2253 self._path = os_helper.TESTFN
2254 self._file = open(self._path, 'wb+')
2255
2256 def tearDown(self):
2257 self._file.close()
2258 self._delete_recursively(self._path)
2259
2260 def test_initialize(self):
2261 # Initialize and check position
2262 self._file.write(bytes('foo' + os.linesep + 'bar', 'ascii'))
2263 pos = self._file.tell()
2264 proxy = mailbox._PartialFile(self._file, 2, 5)
2265 self.assertEqual(proxy.tell(), 0)
2266 self.assertEqual(self._file.tell(), pos)
2267
2268 def test_read(self):
2269 self._file.write(bytes('***bar***', 'ascii'))
2270 self._test_read(mailbox._PartialFile(self._file, 3, 6))
2271
2272 def test_readline(self):
2273 self._file.write(bytes('!!!!!foo%sbar%sfred%sbob!!!!!' %
2274 (os.linesep, os.linesep, os.linesep), 'ascii'))
2275 self._test_readline(mailbox._PartialFile(self._file, 5,
2276 18 + 3 * len(os.linesep)))
2277
2278 def test_readlines(self):
2279 self._file.write(bytes('foo%sbar%sfred%sbob?????' %
2280 (os.linesep, os.linesep, os.linesep), 'ascii'))
2281 self._test_readlines(mailbox._PartialFile(self._file, 0,
2282 13 + 3 * len(os.linesep)))
2283
2284 def test_iteration(self):
2285 self._file.write(bytes('____foo%sbar%sfred%sbob####' %
2286 (os.linesep, os.linesep, os.linesep), 'ascii'))
2287 self._test_iteration(mailbox._PartialFile(self._file, 4,
2288 17 + 3 * len(os.linesep)))
2289
2290 def test_seek_and_tell(self):
2291 self._file.write(bytes('(((foo%sbar%s$$$' % (os.linesep, os.linesep), 'ascii'))
2292 self._test_seek_and_tell(mailbox._PartialFile(self._file, 3,
2293 9 + 2 * len(os.linesep)))
2294
2295 def test_close(self):
2296 self._file.write(bytes('&foo%sbar%s^' % (os.linesep, os.linesep), 'ascii'))
2297 self._test_close(mailbox._PartialFile(self._file, 1,
2298 6 + 3 * len(os.linesep)))
2299
2300
2301 ## Start: tests from the original module (for backward compatibility).
2302
2303 FROM_ = "From [email protected] Sat Jul 24 13:43:35 2004\n"
2304 DUMMY_MESSAGE = """\
2305 From: [email protected]
2306 To: [email protected]
2307 Subject: Simple Test
2308
2309 This is a dummy message.
2310 """
2311
2312 class MaildirTestCase(unittest.TestCase):
2313
2314 def setUp(self):
2315 # create a new maildir mailbox to work with:
2316 self._dir = os_helper.TESTFN
2317 if os.path.isdir(self._dir):
2318 os_helper.rmtree(self._dir)
2319 elif os.path.isfile(self._dir):
2320 os_helper.unlink(self._dir)
2321 os.mkdir(self._dir)
2322 os.mkdir(os.path.join(self._dir, "cur"))
2323 os.mkdir(os.path.join(self._dir, "tmp"))
2324 os.mkdir(os.path.join(self._dir, "new"))
2325 self._counter = 1
2326 self._msgfiles = []
2327
2328 def tearDown(self):
2329 list(map(os.unlink, self._msgfiles))
2330 os_helper.rmdir(os.path.join(self._dir, "cur"))
2331 os_helper.rmdir(os.path.join(self._dir, "tmp"))
2332 os_helper.rmdir(os.path.join(self._dir, "new"))
2333 os_helper.rmdir(self._dir)
2334
2335 def createMessage(self, dir, mbox=False):
2336 t = int(time.time() % 1000000)
2337 pid = self._counter
2338 self._counter += 1
2339 filename = ".".join((str(t), str(pid), "myhostname", "mydomain"))
2340 tmpname = os.path.join(self._dir, "tmp", filename)
2341 newname = os.path.join(self._dir, dir, filename)
2342 with open(tmpname, "w", encoding="utf-8") as fp:
2343 self._msgfiles.append(tmpname)
2344 if mbox:
2345 fp.write(FROM_)
2346 fp.write(DUMMY_MESSAGE)
2347 try:
2348 os.link(tmpname, newname)
2349 except (AttributeError, PermissionError):
2350 with open(newname, "w") as fp:
2351 fp.write(DUMMY_MESSAGE)
2352 self._msgfiles.append(newname)
2353 return tmpname
2354
2355 def test_empty_maildir(self):
2356 """Test an empty maildir mailbox"""
2357 # Test for regression on bug #117490:
2358 # Make sure the boxes attribute actually gets set.
2359 self.mbox = mailbox.Maildir(os_helper.TESTFN)
2360 #self.assertHasAttr(self.mbox, "boxes")
2361 #self.assertEqual(len(self.mbox.boxes), 0)
2362 self.assertIsNone(self.mbox.next())
2363 self.assertIsNone(self.mbox.next())
2364
2365 def test_nonempty_maildir_cur(self):
2366 self.createMessage("cur")
2367 self.mbox = mailbox.Maildir(os_helper.TESTFN)
2368 #self.assertEqual(len(self.mbox.boxes), 1)
2369 self.assertIsNotNone(self.mbox.next())
2370 self.assertIsNone(self.mbox.next())
2371 self.assertIsNone(self.mbox.next())
2372
2373 def test_nonempty_maildir_new(self):
2374 self.createMessage("new")
2375 self.mbox = mailbox.Maildir(os_helper.TESTFN)
2376 #self.assertEqual(len(self.mbox.boxes), 1)
2377 self.assertIsNotNone(self.mbox.next())
2378 self.assertIsNone(self.mbox.next())
2379 self.assertIsNone(self.mbox.next())
2380
2381 def test_nonempty_maildir_both(self):
2382 self.createMessage("cur")
2383 self.createMessage("new")
2384 self.mbox = mailbox.Maildir(os_helper.TESTFN)
2385 #self.assertEqual(len(self.mbox.boxes), 2)
2386 self.assertIsNotNone(self.mbox.next())
2387 self.assertIsNotNone(self.mbox.next())
2388 self.assertIsNone(self.mbox.next())
2389 self.assertIsNone(self.mbox.next())
2390
2391 ## End: tests from the original module (for backward compatibility).
2392
2393
2394 _sample_message = """\
2395 Return-Path: <[email protected]>
2396 X-Original-To: gkj+person@localhost
2397 Delivered-To: gkj+person@localhost
2398 Received: from localhost (localhost [127.0.0.1])
2399 by andy.gregorykjohnson.com (Postfix) with ESMTP id 356ED9DD17
2400 for <gkj+person@localhost>; Wed, 13 Jul 2005 17:23:16 -0400 (EDT)
2401 Delivered-To: [email protected]
2402 Received: from localhost [127.0.0.1]
2403 by localhost with POP3 (fetchmail-6.2.5)
2404 for gkj+person@localhost (single-drop); Wed, 13 Jul 2005 17:23:16 -0400 (EDT)
2405 Received: from andy.gregorykjohnson.com (andy.gregorykjohnson.com [64.32.235.228])
2406 by sundance.gregorykjohnson.com (Postfix) with ESMTP id 5B056316746
2407 for <[email protected]>; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)
2408 Received: by andy.gregorykjohnson.com (Postfix, from userid 1000)
2409 id 490CD9DD17; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)
2410 Date: Wed, 13 Jul 2005 17:23:11 -0400
2411 From: "Gregory K. Johnson" <[email protected]>
2412 To: [email protected]
2413 Subject: Sample message
2414 Message-ID: <[email protected]>
2415 Mime-Version: 1.0
2416 Content-Type: multipart/mixed; boundary="NMuMz9nt05w80d4+"
2417 Content-Disposition: inline
2418 User-Agent: Mutt/1.5.9i
2419
2420
2421 --NMuMz9nt05w80d4+
2422 Content-Type: text/plain; charset=us-ascii
2423 Content-Disposition: inline
2424
2425 This is a sample message.
2426
2427 --
2428 Gregory K. Johnson
2429
2430 --NMuMz9nt05w80d4+
2431 Content-Type: application/octet-stream
2432 Content-Disposition: attachment; filename="text.gz"
2433 Content-Transfer-Encoding: base64
2434
2435 H4sICM2D1UIAA3RleHQAC8nILFYAokSFktSKEoW0zJxUPa7wzJIMhZLyfIWczLzUYj0uAHTs
2436 3FYlAAAA
2437
2438 --NMuMz9nt05w80d4+--
2439 """
2440
2441 _bytes_sample_message = _sample_message.encode('ascii')
2442
2443 _sample_headers = [
2444 ("Return-Path", "<[email protected]>"),
2445 ("X-Original-To", "gkj+person@localhost"),
2446 ("Delivered-To", "gkj+person@localhost"),
2447 ("Received", """from localhost (localhost [127.0.0.1])
2448 by andy.gregorykjohnson.com (Postfix) with ESMTP id 356ED9DD17
2449 for <gkj+person@localhost>; Wed, 13 Jul 2005 17:23:16 -0400 (EDT)"""),
2450 ("Delivered-To", "[email protected]"),
2451 ("Received", """from localhost [127.0.0.1]
2452 by localhost with POP3 (fetchmail-6.2.5)
2453 for gkj+person@localhost (single-drop); Wed, 13 Jul 2005 17:23:16 -0400 (EDT)"""),
2454 ("Received", """from andy.gregorykjohnson.com (andy.gregorykjohnson.com [64.32.235.228])
2455 by sundance.gregorykjohnson.com (Postfix) with ESMTP id 5B056316746
2456 for <[email protected]>; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)"""),
2457 ("Received", """by andy.gregorykjohnson.com (Postfix, from userid 1000)
2458 id 490CD9DD17; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)"""),
2459 ("Date", "Wed, 13 Jul 2005 17:23:11 -0400"),
2460 ("From", """"Gregory K. Johnson" <[email protected]>"""),
2461 ("To", "[email protected]"),
2462 ("Subject", "Sample message"),
2463 ("Mime-Version", "1.0"),
2464 ("Content-Type", """multipart/mixed; boundary="NMuMz9nt05w80d4+\""""),
2465 ("Content-Disposition", "inline"),
2466 ("User-Agent", "Mutt/1.5.9i"),
2467 ]
2468
2469 _sample_payloads = ("""This is a sample message.
2470
2471 --
2472 Gregory K. Johnson
2473 """,
2474 """H4sICM2D1UIAA3RleHQAC8nILFYAokSFktSKEoW0zJxUPa7wzJIMhZLyfIWczLzUYj0uAHTs
2475 3FYlAAAA
2476 """)
2477
2478
2479 class MiscTestCase(unittest.TestCase):
2480 def test__all__(self):
2481 support.check__all__(self, mailbox,
2482 not_exported={"linesep", "fcntl"})
2483
2484
2485 def tearDownModule():
2486 support.reap_children()
2487 # reap_children may have re-populated caches:
2488 if refleak_helper.hunting_for_refleaks():
2489 sys._clear_internal_caches()
2490
2491
2492 if __name__ == '__main__':
2493 unittest.main()