# -*- coding: utf-8 -*- # aioimaplib : an IMAPrev4 lib using python asyncio # Copyright (C) 2016 Bruno Thomas # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import asyncio import logging import ssl import unittest from datetime import datetime, timedelta from unittest.mock import call, MagicMock import pytest from pytz import utc from aioimaplib import aioimaplib, extract_exists, STOP_WAIT_SERVER_PUSH, FetchCommand, IdleCommand from aioimaplib.aioimaplib import Commands, IMAP4ClientProtocol, Command, Abort from aioimaplib import imap_testing_server from aioimaplib.imap_testing_server import Mail from tests.server_fixture import with_ssl_server, with_ssl, with_server, login_user_async, create_server aioimaplib.log.setLevel(logging.WARNING) sh = logging.StreamHandler() sh.setLevel(logging.INFO) sh.setFormatter(logging.Formatter("%(asctime)s %(levelname)s [%(module)s:%(lineno)d] %(message)s")) aioimaplib.log.addHandler(sh) class TestAioimaplibUtils(unittest.TestCase): def setUp(self): self.imap_protocol = IMAP4ClientProtocol(None) self.imap_protocol._handle_line = MagicMock(return_value=None) aioimaplib.get_running_loop = asyncio.new_event_loop # monkey patch to avoid Exception "No running loop" def test_split_responses_no_data(self): self.imap_protocol.data_received(b'') self.imap_protocol._handle_line.assert_not_called() def test_split_responses_regular_lines(self): self.imap_protocol.data_received(b'* BYE Logging out\r\nCAPB2 OK LOGOUT completed\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* BYE Logging out', None), call(b'CAPB2 OK LOGOUT completed', None)]) def test_split_responses_with_message_data(self): cmd = Command('FETCH', 'TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* 1 FETCH (UID 1 RFC822 {26}\r\n...\r\n(mail content)\r\n...\r\n)\r\n' b'TAG OK FETCH completed.\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 1 FETCH (UID 1 RFC822 {26}', None)]) self.imap_protocol._handle_line.assert_has_calls([call(b')', cmd)]) self.imap_protocol._handle_line.assert_has_calls([call(b'TAG OK FETCH completed.', None)]) assert [b'...\r\n(mail content)\r\n...\r\n'] == cmd.response.lines def test_split_responses_with_two_messages_data(self): cmd = Command('FETCH', 'TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* 3 FETCH (UID 3 RFC822 {6}\r\nmail 1)\r\n' b'* 4 FETCH (UID 4 RFC822 {6}\r\nmail 2)\r\n' b'TAG OK FETCH completed.\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 3 FETCH (UID 3 RFC822 {6}', None), call(b')', cmd), call(b'* 4 FETCH (UID 4 RFC822 {6}', None), call(b')', cmd), call(b'TAG OK FETCH completed.', None)]) assert [b'mail 1', b'mail 2'] == cmd.response.lines def test_split_responses_with_flag_fetch_message_data(self): self.imap_protocol.data_received(b'* 1 FETCH (UID 10 FLAGS (FOO))\r\n' b'* 1 FETCH (UID 15 FLAGS (BAR))\r\n' b'TAG OK STORE completed.\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 1 FETCH (UID 10 FLAGS (FOO))', None), call(b'* 1 FETCH (UID 15 FLAGS (BAR))', None), call(b'TAG OK STORE completed.', None)]) def test_split_responses_with_message_data_expunge(self): self.imap_protocol.data_received(b'* 123 EXPUNGE\r\nTAG OK SELECT completed.\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 123 EXPUNGE', None), call(b'TAG OK SELECT completed.', None)]) def test_incomplete_line_with_literal_fetch(self): cmd = Command('FETCH', 'TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* 12 FETCH (BODY[HEADER] {4}\r\nyo\r\n)\r\n* 13 FETCH (BODY[') self.imap_protocol.data_received(b'HEADER] {5}\r\nyo2\r\n)\r\nTAG OK STORE completed.\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 12 FETCH (BODY[HEADER] {4}', None), call(b')', cmd)]) self.imap_protocol._handle_line.assert_has_calls([call(b'* 13 FETCH (BODY[HEADER] {5}', None), call(b')', cmd), call(b'TAG OK STORE completed.', None)]) assert [b'yo\r\n', b'yo2\r\n'] == cmd.response.lines def test_incomplete_lines_during_literal(self): cmd = Command('LIST', 'TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* LIST () "/" {11}\r\nfoo/') self.imap_protocol.data_received(b'bar/') self.imap_protocol.data_received(b'baz\r\n* LIST () "/" qux\r\nTAG OK LIST completed\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* LIST () "/" {11}', None)]) self.imap_protocol._handle_line.assert_has_calls([call(b'* LIST () "/" qux', None), call(b'TAG OK LIST completed', None)]) assert [b'foo/bar/baz'] == cmd.response.lines def test_incomplete_line_during_literal_no_cmd_found(self): self.imap_protocol.data_received(b'* LIST () "/" {7}\r\nfoo/') self.imap_protocol.data_received(b'bar\r\nTAG OK LIST completed\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* LIST () "/" {7}', None)]) self.imap_protocol._handle_line.assert_has_calls([call(b'* LIST () "/" {7}', None), call(b'', Command('NIL', 'unused')), call(b'TAG OK LIST completed', None)]) def test_line_with_literal_no_cmd_found_no_AttributeError_thrown(self): self.imap_protocol.data_received(b'* 3 FETCH (UID 12 RFC822 {4}\r\nmail)\r\n' b'TAG OK FETCH completed.\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 3 FETCH (UID 12 RFC822 {4}', None), call(b')', Command('NIL', 'unused')), call(b'TAG OK FETCH completed.', None)]) def test_line_with_attachment_literals(self): cmd = Command('FETCH', 'TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* 46 FETCH (UID 46 FLAGS () BODYSTRUCTURE (' b'("text" "calendar" ("charset" "UTF-8" "name" {16}\r\nG\xe9n\xe9ration 3.ics)' b' "" NIL "quoted-printable" 365 14 NIL ' b'("attachment" ("filename" {16}\r\nG\xe9n\xe9ration 3.ics)))\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 46 FETCH (UID 46 FLAGS () BODYSTRUCTURE (' b'("text" "calendar" ("charset" "UTF-8" "name" {16}', None), call(b') "" NIL "quoted-printable" 365 14 NIL ' b'("attachment" ("filename" {16}', cmd), call(b')))', cmd)]) assert [b'G\xe9n\xe9ration 3.ics', b'G\xe9n\xe9ration 3.ics'] == cmd.response.lines def test_incomplete_line_followed_by_incomplete_literal(self): cmd = Command('FETCH', 'TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* 2 FETCH (') self.imap_protocol.data_received(b'FLAGS () UID 160016 BODY[] {10}\r\non the ') self.imap_protocol.data_received(b'dot)\r\nTAG OK FETCH completed\r\n') self.imap_protocol._handle_line.assert_has_calls([call(b'* 2 FETCH (FLAGS () UID 160016 BODY[] {10}', None), call(b')', cmd), call(b'TAG OK FETCH completed', None)]) assert [b'on the dot'] == cmd.response.lines # cf 1st FETCH in https://tools.ietf.org/html/rfc3501#section-8 example def test_incomplete_fetch_message_attributes_without_literal(self): cmd = FetchCommand('TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) line = b'* 12 FETCH (FLAGS (\Seen) BODY ("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 3028 \r\n' cmd.append_to_resp(line) self.imap_protocol.data_received(line) line = b'92))\r\nTAG OK FETCH completed\r\n' cmd.append_to_resp(line) self.imap_protocol.data_received(line) self.imap_protocol._handle_line.assert_has_calls( [call(b'* 12 FETCH (FLAGS (\Seen) BODY ("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 3028 ', None), call(b'92))', cmd), call(b'TAG OK FETCH completed', None)]) def test_incomplete_fetch_with_incomplete_line(self): cmd = FetchCommand('TAG') self.imap_protocol._handle_line = MagicMock(return_value=cmd) self.imap_protocol.data_received(b'* 21 FETCH (FLAGS (\Seen) BODY[] {16}\r\nincomplete fetch') self.imap_protocol.data_received(b')\r\nTAG OK FETCH completed\r\n') self.imap_protocol._handle_line.assert_has_calls( [call(b'* 21 FETCH (FLAGS (\Seen) BODY[] {16}', None), call(b')', cmd), call(b'TAG OK FETCH completed', None)]) def test_command_repr(self): assert 'tag NAME' == str(Command('NAME', 'tag')) assert 'tag NAME arg1 arg2' == str(Command('NAME', 'tag', 'arg1', 'arg2')) assert 'tag UID NAME arg' == str(Command('NAME', 'tag', 'arg', prefix='UID')) assert 'tag UID NAME' == str(Command('NAME', 'tag', prefix='UID')) class TestDataReceived(unittest.TestCase): def setUp(self): self.imap_protocol = IMAP4ClientProtocol(None) aioimaplib.get_running_loop = asyncio.new_event_loop # monkey patch to avoid Exception "No running loop" def test_when_idle_continuation_line_in_same_dataframe_as_status_update(self): queue = asyncio.Queue() cmd = IdleCommand('TAG', queue) self.imap_protocol.pending_sync_command = cmd self.imap_protocol.data_received(b'+ idling\r\n* 1 EXISTS\r\n* 1 RECENT\r\n') assert self.imap_protocol._idle_event.is_set() assert [b'1 EXISTS', b'1 RECENT'] == queue.get_nowait() class TestFetchWaitsForAllMessageAttributes(unittest.TestCase): def setUp(self): aioimaplib.get_running_loop = asyncio.new_event_loop # monkey patch to avoid Exception "No running loop" def test_empty_fetch(self): assert not FetchCommand('TAG').wait_data() def test_simple_fetch(self): fetch = FetchCommand('TAG') fetch.append_to_resp(b'12 FETCH (FLAGS (\Seen))') assert not fetch.wait_data() def test_simple_fetch_with_two_lines(self): fetch = FetchCommand('TAG') fetch.append_to_resp(b'12 FETCH (FLAGS (\Seen) BODY ("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 3028') assert fetch.wait_data() fetch.append_to_resp(b'92))') assert not fetch.wait_data() def test_fetch_with_literal(self): fetch = FetchCommand('TAG') fetch.append_to_resp(b'12 FETCH (FLAGS () BODY[] {13}') fetch.begin_literal_data(13, b'literal (data') fetch.append_to_resp(b')') assert not fetch.wait_data() def test_fetch_only_the_last_message_data(self): fetch = FetchCommand('TAG') fetch.append_to_resp(b'12 FETCH (FLAGS (\Seen)') # not closed on purpose assert fetch.wait_data() fetch.append_to_resp(b'13 FETCH (FLAGS (\Seen)') assert fetch.wait_data() fetch.append_to_resp(b')') assert not fetch.wait_data() @pytest.mark.asyncio() async def test_login(with_server): imap_client = aioimaplib.IMAP4(port=12345, loop=asyncio.get_running_loop(), timeout=3) await asyncio.wait_for(imap_client.wait_hello_from_server(), 2) result, data = await imap_client.login('user', 'password') assert aioimaplib.AUTH == imap_client.protocol.state assert 'OK' == result assert b'LOGIN completed' == data[-1] assert imap_client.has_capability('IDLE') assert imap_client.has_capability('UIDPLUS') @pytest.mark.asyncio() async def test_xoauth2(with_server): imap_client = aioimaplib.IMAP4(port=12345, loop=asyncio.get_running_loop(), timeout=3) await asyncio.wait_for(imap_client.wait_hello_from_server(), 2) result, data = await imap_client.xoauth2('user', 'myspecialtoken') assert aioimaplib.AUTH == imap_client.protocol.state assert 'OK' == result assert b'AUTHENTICATE completed' == data[-1] @pytest.mark.asyncio() async def test_login_with_special_characters(with_server): imap_client = aioimaplib.IMAP4(port=12345, loop=asyncio.get_running_loop(), timeout=3) await asyncio.wait_for(imap_client.wait_hello_from_server(), 2) result, data = await imap_client.login('user', 'pass"word') assert aioimaplib.AUTH == imap_client.protocol.state assert 'OK' == result assert b'LOGIN completed' == data[-1] @pytest.mark.asyncio() async def test_login_twice(with_server): with pytest.raises(aioimaplib.Error) as expected: imap_client = await login_user_async('user', 'pass') await imap_client.login('user', 'password') assert expected == 'command LOGIN illegal in state AUTH' @pytest.mark.asyncio() async def test_logout(with_server): imap_client = await login_user_async('user', 'pass') result, data = await imap_client.logout() assert 'OK' == result assert [b'BYE Logging out', b'LOGOUT completed'] == data assert aioimaplib.LOGOUT == imap_client.protocol.state @pytest.mark.asyncio() async def test_select_no_messages(with_server): imap_client = await login_user_async('user', 'pass') resp = await imap_client.select() assert 'OK' == resp[0] assert 0 == extract_exists(resp) assert aioimaplib.SELECTED == imap_client.protocol.state @pytest.mark.asyncio() async def test_examine_no_messages(with_server): imap_client = await login_user_async('user', 'pass') assert 0 == extract_exists((await imap_client.examine())) assert aioimaplib.AUTH == imap_client.protocol.state @pytest.mark.asyncio() async def test_search_two_messages(with_server): with_server.receive(Mail.create(['user'])) with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) result, data = await imap_client.search('ALL') assert 'OK' == result assert b'1 2' == data[0] @pytest.mark.asyncio() async def test_search_messages(with_server): """Increase compatibility with https://docs.python.org/3/library/imaplib.html#imap4-example.""" with_server.receive(Mail.create(['user'])) with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) # E.g. typ, data = M.search(None, 'ALL') result, data = await imap_client.search(None, 'ALL') assert 'OK' == result assert b'1 2' == data[0] @pytest.mark.asyncio() async def test_uid_with_illegal_command(with_server): imap_client = await login_user_async('user', 'pass', select=True) for command in {'COPY', 'FETCH', 'STORE', 'EXPUNGE', 'MOVE'}.symmetric_difference(Commands.keys()): with pytest.raises(aioimaplib.Abort) as expected: await imap_client.uid(command) assert ('command UID only possible with COPY, FETCH, EXPUNGE (w/UIDPLUS) or STORE (was %s)' % command) in str(expected) @pytest.mark.asyncio() async def test_search_three_messages_by_uid(with_server): imap_client = await login_user_async('user', 'pass', select=True) with_server.receive(Mail.create(['user'])) # id=1 uid=1 with_server.receive(Mail.create(['user']), mailbox='OTHER_MAILBOX') # id=1 uid=1 with_server.receive(Mail.create(['user'])) # id=2 uid=2 assert b'1 2' == (await imap_client.search('ALL')).lines[0] assert b'1 2' == (await imap_client.uid_search('ALL')).lines[0] await imap_client.select('OTHER_MAILBOX') assert b'1' == (await imap_client.uid_search('ALL')).lines[0] @pytest.mark.asyncio() async def test_fetch(with_server): imap_client = await login_user_async('user', 'pass', select=True) mail = Mail.create(['user'], mail_from='me', subject='hello', content='pleased to meet you, wont you guess my name ?') with_server.receive(mail) result, data = await imap_client.fetch('1', '(RFC822)') content = mail.as_bytes() assert 'OK' == result assert [ b'1 FETCH (RFC822 {%d}' % len(content), content, b')', b'FETCH completed.' ] == data @pytest.mark.asyncio() async def test_fetch_by_uid_without_body(with_server): imap_client = await login_user_async('user', 'pass', select=True) mail = Mail.create(['user'], mail_from='me', subject='hello', content='pleased to meet you, wont you guess my name ?') with_server.receive(mail) response = (await imap_client.uid('fetch', '1', '(UID FLAGS)')) assert 'OK' == response.result assert b'1 FETCH (UID 1 FLAGS ())' == response.lines[0] @pytest.mark.asyncio() async def test_fetch_by_uid(with_server): imap_client = await login_user_async('user', 'pass', select=True) mail = Mail.create(['user'], mail_from='me', subject='hello', content='pleased to meet you, wont you guess my name ?') with_server.receive(mail) response = (await imap_client.uid('fetch', '1', '(RFC822)')) assert 'OK' == response.result assert mail.as_bytes() == response.lines[1] @pytest.mark.asyncio() async def test_idle(with_server): imap_client = await login_user_async('user', 'pass', select=True) idle = await imap_client.idle_start(timeout=0.3) with_server.receive(Mail.create(to=['user'], mail_from='me', subject='hello')) assert [b'1 EXISTS', b'1 RECENT'] == (await imap_client.wait_server_push()) imap_client.idle_done() assert ('OK', [b'IDLE terminated']) == (await asyncio.wait_for(idle, 1)) assert imap_client._idle_waiter._cancelled with pytest.raises(asyncio.TimeoutError): await imap_client.wait_server_push(timeout=0.1) @pytest.mark.asyncio() async def test_idle_loop(with_server): imap_client = await login_user_async('user', 'pass', select=True) idle = await imap_client.idle_start(timeout=0.3) with_server.receive(Mail.create(to=['user'], mail_from='me', subject='hello')) data = list() while imap_client.has_pending_idle(): data.append((await imap_client.wait_server_push())) if data[-1] == STOP_WAIT_SERVER_PUSH: imap_client.idle_done() await asyncio.wait_for(idle, 1) assert [[b'1 EXISTS', b'1 RECENT'], STOP_WAIT_SERVER_PUSH] == data @pytest.mark.asyncio() async def test_idle_stop(with_server): imap_client = await login_user_async('user', 'pass', select=True) idle = await imap_client.idle_start() assert (await imap_client.stop_wait_server_push()) assert STOP_WAIT_SERVER_PUSH == (await imap_client.wait_server_push()) imap_client.idle_done() await asyncio.wait_for(idle, 1) @pytest.mark.asyncio() async def test_idle_stop_does_nothing_if_no_pending_idle(with_server): imap_client = await login_user_async('user', 'pass', select=True) assert not (await imap_client.stop_wait_server_push()) @pytest.mark.asyncio() async def test_idle_error_response(with_server): imap_client = await login_user_async('user', 'pass', select=True) conn = with_server.get_connection('user') def idle_error(tag, *args): conn.error(tag, "Error initiating IDLE") conn.idle = idle_error with pytest.raises(Abort): await imap_client.idle_start() @pytest.mark.asyncio() async def test_store_and_search_by_keyword(with_server): with_server.receive(Mail.create(['user'])) with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) assert b'' == (await imap_client.uid_search('KEYWORD FOO', charset=None)).lines[0] assert 'OK' == (await imap_client.uid('store', '1', '+FLAGS (FOO)')).result assert b'1' == (await imap_client.uid_search('KEYWORD FOO', charset=None)).lines[0] assert b'2' == (await imap_client.uid_search('UNKEYWORD FOO', charset=None)).lines[0] @pytest.mark.asyncio() async def test_expunge_messages(with_server): with_server.receive(Mail.create(['user'])) with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) assert ('OK', [b'1 EXPUNGE', b'2 EXPUNGE', b'EXPUNGE completed.']) == (await imap_client.expunge()) assert 0 == extract_exists((await imap_client.select())) @pytest.mark.asyncio() async def test_copy_messages(with_server): with_server.receive(Mail.create(['user'])) with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) result, _ = await imap_client.copy('1', '2', 'MAILBOX') assert 'OK' == result assert 2 == extract_exists((await imap_client.select('MAILBOX'))) @pytest.mark.asyncio() async def test_copy_messages_by_uid(with_server): with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) result, _ = await imap_client.uid('copy', '1', 'MAILBOX') assert 'OK' == result assert 1 == extract_exists((await imap_client.select('MAILBOX'))) @pytest.mark.asyncio() async def test_concurrency_1_executing_sync_commands_sequentially(with_server): imap_client = await login_user_async('user', 'pass') f1 = asyncio.ensure_future(imap_client.examine('INBOX')) f2 = asyncio.ensure_future(imap_client.examine('MAILBOX')) await asyncio.wait([f1, f2]) assert f1.exception() is None assert f2.exception() is None @pytest.mark.asyncio() async def test_concurrency_2_executing_same_async_commands_sequentially(with_server): with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) f1 = asyncio.ensure_future(imap_client.fetch('1', '(RFC822)')) f2 = asyncio.ensure_future(imap_client.fetch('1', '(RFC822)')) await asyncio.wait([f1, f2]) assert f1.exception() is None assert f2.exception() is None @pytest.mark.asyncio() async def test_concurrency_3_executing_async_commands_in_parallel(with_server): # cf valid example in https://tools.ietf.org/html/rfc3501#section-5.5 with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) store = asyncio.ensure_future(imap_client.store('1', '+FLAGS (FOO)')) copy = asyncio.ensure_future(imap_client.copy('1', 'MBOX')) expunge = asyncio.ensure_future(imap_client.expunge()) await asyncio.wait([store, copy, expunge]) assert 0 == extract_exists((await imap_client.select())) assert 1 == extract_exists((await imap_client.select('MBOX'))) assert b'1' == (await imap_client.search('KEYWORD FOO', charset=None)).lines[0] @pytest.mark.asyncio() async def test_concurrency_4_sync_command_waits_for_async_commands_to_finish(with_server): with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) asyncio.ensure_future(imap_client.copy('1', 'MBOX')) asyncio.ensure_future(imap_client.expunge()) examine = asyncio.ensure_future(imap_client.examine('MBOX')) assert 1 == extract_exists((await asyncio.wait_for(examine, 1))) @pytest.mark.asyncio() async def test_noop(with_server): imap_client = await login_user_async('user', 'pass') assert ('OK', [b'NOOP completed.']) == (await imap_client.noop()) @pytest.mark.asyncio() async def test_noop_with_untagged_data(with_server): imap_client = await login_user_async('user', 'pass') with_server.receive(Mail.create(['user'])) assert ('OK', [b'1 EXISTS', b'1 RECENT', b'NOOP completed.']) == (await imap_client.noop()) @pytest.mark.asyncio() async def test_check(with_server): imap_client = await login_user_async('user', 'pass', select=True) assert ('OK', [b'CHECK completed.']) == (await imap_client.check()) @pytest.mark.asyncio() async def test_close(with_server): imap_client = await login_user_async('user', 'pass', select=True) assert imap_testing_server.SELECTED == with_server.get_connection('user').state assert ('OK', [b'CLOSE completed.']) == (await imap_client.close()) assert imap_testing_server.AUTH == with_server.get_connection('user').state @pytest.mark.asyncio() async def test_status(with_server): imap_client = await login_user_async('user', 'pass') assert b'INBOX (MESSAGES 0 UIDNEXT 1)' == \ (await imap_client.status('INBOX', '(MESSAGES UIDNEXT)')).lines[0] @pytest.mark.asyncio() async def test_subscribe_unsubscribe_lsub(with_server): imap_client = await login_user_async('user', 'pass') assert ('OK', [b'SUBSCRIBE completed.']) == (await imap_client.subscribe('#fr.soc.feminisme')) assert ('OK', [b'() "." #fr.soc.feminisme', b'LSUB completed.']) == \ (await imap_client.lsub('#fr.', 'soc.*')) assert ('OK', [b'UNSUBSCRIBE completed.']) == (await imap_client.unsubscribe('#fr.soc.feminisme')) assert ('OK', [b'LSUB completed.']) == (await imap_client.lsub('#fr', '.*')) @pytest.mark.asyncio() async def test_create_delete_mailbox(with_server): imap_client = await login_user_async('user', 'pass') assert 'NO' == (await imap_client.status('MBOX', '(MESSAGES)')).result assert ('OK', [b'CREATE completed.']) == (await imap_client.create('MBOX')) assert 'OK' == (await imap_client.status('MBOX', '(MESSAGES)')).result assert ('OK', [b'DELETE completed.']) == (await imap_client.delete('MBOX')) assert 'NO' == (await imap_client.status('MBOX', '(MESSAGES)')).result @pytest.mark.asyncio() async def test_rename_mailbox(with_server): imap_client = await login_user_async('user', 'pass') assert 'NO' == (await imap_client.status('MBOX', '(MESSAGES)')).result assert ('OK', [b'RENAME completed.']) == (await imap_client.rename('INBOX', 'MBOX')) assert 'OK' == (await imap_client.status('MBOX', '(MESSAGES)')).result @pytest.mark.asyncio() async def test_list(with_server): imap_client = await login_user_async('user', 'pass') assert ('OK', [b'() "/" Drafts', b'() "/" INBOX', b'() "/" Sent', b'() "/" Trash', b'LIST completed.']) == (await imap_client.list('""', '.*')) await imap_client.create('MYBOX') assert ('OK', [b'() "/" Drafts', b'() "/" INBOX', b'() "/" MYBOX', b'() "/" Sent', b'() "/" Trash', b'LIST completed.']) == \ (await imap_client.list('""', '.*')) @pytest.mark.asyncio() async def test_get_quotaroot(with_server): imap_client = await login_user_async('user', 'pass') with_server.receive(Mail.create(['user'])) response = await imap_client.getquotaroot('INBOX') assert response.lines == [b'INBOX (STORAGE 292 5000)', b'GETQUOTAROOT completed.'] @pytest.mark.asyncio() async def test_append(with_server): imap_client = await login_user_async('user@mail', 'pass') assert 0 == extract_exists((await imap_client.examine('INBOX'))) msg = Mail.create(['user@mail'], subject='append msg', content='do you see me ?') response = await imap_client.append(msg.as_bytes(), mailbox='INBOX', flags='FOO BAR', date=datetime.now(tz=utc), ) assert 'OK' == response.result assert b'1] APPEND completed' in response.lines[0] assert 1 == extract_exists((await imap_client.examine('INBOX'))) @pytest.mark.asyncio() async def test_rfc5032_within(with_server): with_server.receive(Mail.create(['user'], date=datetime.now(tz=utc) - timedelta(seconds=84600 * 3))) # 1 with_server.receive(Mail.create(['user'], date=datetime.now(tz=utc) - timedelta(seconds=84600))) # 2 with_server.receive(Mail.create(['user'])) # 3 imap_client = await login_user_async('user', 'pass', select=True) assert b'1' == (await imap_client.search('OLDER', '84700')).lines[0] assert b'2 3' == (await imap_client.search('YOUNGER', '84700')).lines[0] @pytest.mark.asyncio() async def test_rfc4315_uidplus_expunge(with_server): with_server.receive(Mail.create(['user'])) with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) assert ('OK', [b'1 EXPUNGE', b'UID EXPUNGE completed.']) == (await imap_client.uid('expunge', '1:1')) assert 1 == extract_exists((await imap_client.select())) @pytest.mark.asyncio() async def test_rfc6851_move(with_server): with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) uidvalidity = with_server.get_connection('user').uidvalidity assert ('OK', [b'OK [COPYUID %d 1:1 1:1]' % uidvalidity, b'1 EXPUNGE', b'Done']) == \ (await imap_client.move('1:1', 'Trash')) assert 0 == extract_exists((await imap_client.select())) assert 1 == extract_exists((await imap_client.select('Trash'))) @pytest.mark.asyncio() async def test_rfc6851_uidmove(with_server): with_server.receive(Mail.create(['user'])) imap_client = await login_user_async('user', 'pass', select=True) uidvalidity = with_server.get_connection('user').uidvalidity assert ('OK', [b'OK [COPYUID %d 1:1 1:1]' % uidvalidity, b'1 EXPUNGE', b'Done']) == \ (await imap_client.uid('move', '1:1', 'Trash')) assert 0 == extract_exists((await imap_client.select())) assert 1 == extract_exists((await imap_client.select('Trash'))) @pytest.mark.asyncio() async def test_rfc5161_enable(with_server): imap_client = await login_user_async('user', 'pass') assert ('OK', [b'X-GOOD-IDEA CONDSTORE enabled']) == \ (await imap_client.enable('X-GOOD-IDEA CONDSTORE')) @pytest.mark.asyncio() async def test_rfc2342_namespace(with_server): imap_client = await login_user_async('user', 'pass') response = await imap_client.namespace() assert ('OK', [b'(("" "/")) NIL NIL', b'NAMESPACE command completed']) == response @pytest.mark.asyncio() async def test_rfc2971_id(with_server): imap_client = await login_user_async('user', 'pass') response = await imap_client.id() assert ('OK', [b'ID command completed']) == response @pytest.mark.asyncio() async def test_callback_is_called_when_connection_is_lost(event_loop): imapserver = create_server(None, event_loop) srv = await imapserver.run_server(host='127.0.0.1', port=12345, fetch_chunk_size=64, ssl_context=None) async with srv: await srv.start_serving() queue = asyncio.Queue() imap_client = aioimaplib.IMAP4(port=12345, loop=event_loop, timeout=3, conn_lost_cb=lambda m: queue.put_nowait('called with %s' % m)) await asyncio.wait_for(imap_client.wait_hello_from_server(), 2) await imap_client.login('login', 'password') imapserver.reset() srv.close() await asyncio.wait_for(srv.wait_closed(), 1) assert 'called with None' == (await asyncio.wait_for(queue.get(), timeout=2)) @pytest.mark.asyncio() async def test_client_can_connect_to_server_over_ssl(with_ssl, with_ssl_server): ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=with_ssl[1]) imap_client = aioimaplib.IMAP4_SSL(port=12345, loop=asyncio.get_running_loop(), ssl_context=ssl_context) await asyncio.wait_for(imap_client.wait_hello_from_server(), 2) assert 'IMAP4REV1' == imap_client.protocol.imap_version assert {'IMAP4rev1', 'YESAUTH'} == imap_client.protocol.capabilities assert imap_client.has_capability('YESAUTH')