def test_internaldate_style(self):
self.check_normalised_and_not(
b' 9-Feb-2007 17:08:08 -0430',
datetime(2007, 2, 9, 17, 8, 8, 0, FixedOffset(-4 * 60 - 30)))
self.check_normalised_and_not(
b'19-Feb-2007 17:08:08 0400',
datetime(2007, 2, 19, 17, 8, 8, 0, FixedOffset(4 * 60)))
def test_dots_for_time_separator(self):
# As reported in issue #154.
self.check_normalised_and_not(
b'Sat, 8 May 2010 16.03.09 +0200',
datetime(2010, 5, 8, 16, 3, 9, 0, FixedOffset(120)))
self.check_normalised_and_not(
b'Tue, 18 May 2010 16.03.09 -0200',
datetime(2010, 5, 18, 16, 3, 9, 0, FixedOffset(-120)))
self.check_normalised_and_not(
b'Wednesday,18 August 2010 16.03.09 -0200',
datetime(2010, 8, 18, 16, 3, 9, 0, FixedOffset(-120)))
def test_INTERNALDATE(self):
def check(date_str, expected_dt):
output = parse_fetch_response(['3 (INTERNALDATE "%s")' % date_str],
normalise_times=False)
actual_dt = output[3]['INTERNALDATE']
self.assertEqual(actual_dt, expected_dt)
check(' 9-Feb-2007 17:08:08 -0430',
datetime(2007, 2, 9, 17, 8, 8, 0, FixedOffset(-4 * 60 - 30)))
check('12-Feb-2007 17:08:08 +0200',
datetime(2007, 2, 12, 17, 8, 8, 0, FixedOffset(2 * 60)))
check(' 9-Dec-2007 17:08:08 +0000',
datetime(2007, 12, 9, 17, 8, 8, 0, FixedOffset(0)))
def test_ENVELOPE(self):
envelope_str = ('1 (ENVELOPE ( '
'"Sun, 24 Mar 2013 22:06:10 +0200" '
'"subject" '
'(("name" NIL "address1" "domain1.com")) '
'((NIL NIL "address2" "domain2.com")) '
'(("name" NIL "address3" "domain3.com")) '
'NIL'
'((NIL NIL "address4" "domain4.com") '
'("person" NIL "address4b" "domain4b.com")) '
'NIL "<reply-to-id>" "<msg_id>"))')
output = parse_fetch_response([envelope_str], normalise_times=False)
self.assertSequenceEqual(
output[1]['ENVELOPE'],
Envelope(datetime(2013, 3, 24, 22, 6, 10,
tzinfo=FixedOffset(120)), "subject",
(Address("name", None, "address1", "domain1.com"), ),
(Address(None, None, "address2", "domain2.com"), ),
(Address("name", None, "address3", "domain3.com"), ),
None,
(Address(None, None, "address4", "domain4.com"),
Address("person", None, "address4b", "domain4b.com")),
None, "<reply-to-id>", "<msg_id>"))
def test_ENVELOPE(self):
envelope_str = (
b'1 (ENVELOPE ( '
b'"Sun, 24 Mar 2013 22:06:10 +0200" '
b'"subject" '
b'(("name" NIL "address1" "domain1.com")) ' # from (name and address)
b'((NIL NIL "address2" "domain2.com")) ' # sender (just address)
b'(("name" NIL "address3" "domain3.com") NIL) ' # reply to
b'NIL' # to (no address)
b'((NIL NIL "address4" "domain4.com") ' # cc
b'("person" NIL "address4b" "domain4b.com")) '
b'NIL ' # bcc
b'"<reply-to-id>" '
b'"<msg_id>"))')
output = parse_fetch_response([envelope_str], normalise_times=False)
self.assertSequenceEqual(
output[1][b'ENVELOPE'],
Envelope(datetime(2013, 3, 24, 22, 6, 10,
tzinfo=FixedOffset(120)), b"subject",
(Address(b"name", None, b"address1", b"domain1.com"), ),
(Address(None, None, b"address2", b"domain2.com"), ),
(Address(b"name", None, b"address3", b"domain3.com"), ),
None,
(Address(None, None, b"address4", b"domain4.com"),
Address(b"person", None, b"address4b", b"domain4b.com")),
None, b"<reply-to-id>", b"<msg_id>"))
def test_INTERNALDATE(self):
out = parse_fetch_response(
[b'1 (INTERNALDATE " 9-Feb-2007 17:08:08 -0430")'],
normalise_times=False)
self.assertEqual(
out[1][b'INTERNALDATE'],
datetime(2007, 2, 9, 17, 8, 8, 0, FixedOffset(-4 * 60 - 30)))
def test_INTERNALDATE_normalised(self):
output = parse_fetch_response([b'3 (INTERNALDATE " 9-Feb-2007 17:08:08 -0430")'])
dt = output[3][b'INTERNALDATE']
self.assertTrue(dt.tzinfo is None) # Returned date should be in local timezone
expected_dt = datetime_to_native(
datetime(2007, 2, 9, 17, 8, 8, 0, FixedOffset(-4 * 60 - 30)))
self.assertEqual(dt, expected_dt)
def test_INTERNALDATE_normalised(self):
def check(date_str, expected_dt):
output = parse_fetch_response(['3 (INTERNALDATE "%s")' % date_str])
actual_dt = output[3]['INTERNALDATE']
self.assertTrue(actual_dt.tzinfo is
None) # Returned date should be in local timezone
expected_dt = datetime_to_native(expected_dt)
self.assertEqual(actual_dt, expected_dt)
check(' 9-Feb-2007 17:08:08 -0430',
datetime(2007, 2, 9, 17, 8, 8, 0, FixedOffset(-4 * 60 - 30)))
check('12-Feb-2007 17:08:08 +0200',
datetime(2007, 2, 12, 17, 8, 8, 0, FixedOffset(2 * 60)))
check(' 9-Dec-2007 17:08:08 +0000',
datetime(2007, 12, 9, 17, 8, 8, 0, FixedOffset(0)))
def test_with_msg_time(self, datetime_to_INTERNALDATE):
datetime_to_INTERNALDATE.return_value = 'somedate'
self.client._imap.append.return_value = ('OK', [b'Good'])
msg = b'bye'
self.client.append('foobar', msg, ['FLAG', 'WAVE'],
datetime(2009, 4, 5, 11, 0, 5, 0, FixedOffset(2 * 60)))
self.assertTrue(datetime_to_INTERNALDATE.called)
self.client._imap.append.assert_called_with(
b'"foobar"', '(FLAG WAVE)', '"somedate"', msg)
def test_fetch(self):
# Generate a fresh message-id each time because Gmail is
# clever and will treat appends of messages with
# previously seen message-ids as the same message. This
# breaks our tests when the test message is updated.
msg_id_header = make_msgid()
msg = ("Message-ID: %s\r\n" % msg_id_header) + MULTIPART_MESSAGE
self.client.select_folder(self.base_folder)
self.append_msg(msg)
self.client.normalise_times = False
fields = ["RFC822", b"FLAGS", "INTERNALDATE", "ENVELOPE"]
msg_id = self.client.search()[0]
resp = self.client.fetch(msg_id, fields)
self.assertEqual(len(resp), 1)
msginfo = resp[msg_id]
extra_fields = [b"SEQ"]
if self.condstore_enabled:
extra_fields.append(b"MODSEQ")
self.assertSetEqual(
set(msginfo.keys()),
set([to_bytes(f) for f in fields] + extra_fields),
)
self.assertEqual(msginfo[b"SEQ"], 1)
self.assertEqual(msginfo[b"RFC822"], to_bytes(msg))
self.assertIsInstance(msginfo[b"INTERNALDATE"], datetime)
self.assertIsInstance(msginfo[b"FLAGS"], tuple)
self.assertSequenceEqual(
msginfo[b"ENVELOPE"],
Envelope(
datetime(2010, 3, 16, 16, 45, 32, tzinfo=FixedOffset(0)),
b"A multipart message",
(Address(b"Bob Smith", None, b"bob", b"smith.com"), ),
(Address(b"Bob Smith", None, b"bob", b"smith.com"), ),
(Address(b"Bob Smith", None, b"bob", b"smith.com"), ),
(
Address(b"Some One", None, b"some", b"one.com"),
Address(None, None, b"foo", b"foo.com"),
),
None,
None,
None,
to_bytes(msg_id_header),
),
)
def test_mixed_types(self):
self.assertEqual(
parse_fetch_response([
(b'1 (INTERNALDATE " 9-Feb-2007 17:08:08 +0100" RFC822 {21}',
b'Subject: test\r\n\r\nbody'), b')'
]), {
1: {
b'INTERNALDATE':
datetime_to_native(
datetime(2007, 2, 9, 17, 8, 8, 0, FixedOffset(60))),
b'RFC822':
b'Subject: test\r\n\r\nbody',
b'SEQ':
1
}
})
def test_fetch(self):
# Generate a fresh message-id each time because Gmail is
# clever and will treat appends of messages with
# previously seen message-ids as the same message. This
# breaks our tests when the test message is updated.
msg_id_header = make_msgid()
msg = ('Message-ID: %s\r\n' % msg_id_header) + MULTIPART_MESSAGE
self.client.select_folder(self.base_folder)
self.append_msg(msg)
self.client.normalise_times = False
fields = ['RFC822', b'FLAGS', 'INTERNALDATE', 'ENVELOPE']
msg_id = self.client.search()[0]
resp = self.client.fetch(msg_id, fields)
self.assertEqual(len(resp), 1)
msginfo = resp[msg_id]
extra_fields = [b'SEQ']
if self.condstore_enabled:
extra_fields.append(b'MODSEQ')
self.assertSetEqual(
set(msginfo.keys()),
set([to_bytes(f) for f in fields] + extra_fields),
)
self.assertEqual(msginfo[b'SEQ'], 1)
self.assertEqual(msginfo[b'RFC822'], to_bytes(msg))
self.assertIsInstance(msginfo[b'INTERNALDATE'], datetime)
self.assertIsInstance(msginfo[b'FLAGS'], tuple)
self.assertSequenceEqual(
msginfo[b'ENVELOPE'],
Envelope(
datetime(2010, 3, 16, 16, 45, 32,
tzinfo=FixedOffset(0)), b'A multipart message',
(Address(b'Bob Smith', None, b'bob', b'smith.com'), ),
(Address(b'Bob Smith', None, b'bob', b'smith.com'), ),
(Address(b'Bob Smith', None, b'bob', b'smith.com'), ),
(Address(b'Some One', None, b'some', b'one.com'),
Address(None, None, b'foo', b'foo.com')), None, None,
None, to_bytes(msg_id_header)))
def test_with_timezone(self):
dt = datetime(2009, 1, 2, 3, 4, 5, 0, FixedOffset(2 * 60 + 30))
self.assertEqual(datetime_to_INTERNALDATE(dt),
'02-Jan-2009 03:04:05 +0230')
def test_GMT(self):
self._check(FixedOffset(0), timedelta(0), '+0000')
def test_positive(self):
self._check(FixedOffset(30), timedelta(minutes=30), '+0030')
self._check(FixedOffset(2 * 60), timedelta(hours=2), '+0200')
self._check(FixedOffset(11 * 60 + 30), timedelta(hours=11, minutes=30),
'+1130')
def test_negative(self):
self._check(FixedOffset(-30), timedelta(minutes=-30), '-0030')
self._check(FixedOffset(-2 * 60), timedelta(hours=-2), '-0200')
self._check(FixedOffset(-11 * 60 - 30),
timedelta(minutes=(-11 * 60) - 30), '-1130')
def test_rfc822_style(self):
self.check_normalised_and_not(
b'Sun, 24 Mar 2013 22:06:10 +0200',
datetime(2013, 3, 24, 22, 6, 10, 0, FixedOffset(120)))
def test_without_timezone(self, for_system):
dt = datetime(2009, 1, 2, 3, 4, 5, 0)
for_system.return_value = FixedOffset(-5 * 60)
self.assertEqual(datetime_to_INTERNALDATE(dt),
'02-Jan-2009 03:04:05 -0500')
