1"""Test script for poplib module."""
2
3# Modified by Giampaolo Rodola' to give poplib.POP3 and poplib.POP3_SSL
4# a real test suite
5
6import poplib
7import asyncore
8import asynchat
9import socket
10import os
11import time
12import errno
13
14from unittest import TestCase, skipUnless
15from test import test_support
16from test.test_support import HOST
17threading = test_support.import_module('threading')
18
19
20# the dummy data returned by server when LIST and RETR commands are issued
21LIST_RESP = '1 1\r\n2 2\r\n3 3\r\n4 4\r\n5 5\r\n.\r\n'
22RETR_RESP = """From: [email protected]\
23\r\nContent-Type: text/plain\r\n\
24MIME-Version: 1.0\r\n\
25Subject: Dummy\r\n\
26\r\n\
27line1\r\n\
28line2\r\n\
29line3\r\n\
30.\r\n"""
31
32
33class DummyPOP3Handler(asynchat.async_chat):
34
35    def __init__(self, conn):
36        asynchat.async_chat.__init__(self, conn)
37        self.set_terminator("\r\n")
38        self.in_buffer = []
39        self.push('+OK dummy pop3 server ready.')
40
41    def collect_incoming_data(self, data):
42        self.in_buffer.append(data)
43
44    def found_terminator(self):
45        line = ''.join(self.in_buffer)
46        self.in_buffer = []
47        cmd = line.split(' ')[0].lower()
48        space = line.find(' ')
49        if space != -1:
50            arg = line[space + 1:]
51        else:
52            arg = ""
53        if hasattr(self, 'cmd_' + cmd):
54            method = getattr(self, 'cmd_' + cmd)
55            method(arg)
56        else:
57            self.push('-ERR unrecognized POP3 command "%s".' %cmd)
58
59    def handle_error(self):
60        raise
61
62    def push(self, data):
63        asynchat.async_chat.push(self, data + '\r\n')
64
65    def cmd_echo(self, arg):
66        # sends back the received string (used by the test suite)
67        self.push(arg)
68
69    def cmd_user(self, arg):
70        if arg != "guido":
71            self.push("-ERR no such user")
72        self.push('+OK password required')
73
74    def cmd_pass(self, arg):
75        if arg != "python":
76            self.push("-ERR wrong password")
77        self.push('+OK 10 messages')
78
79    def cmd_stat(self, arg):
80        self.push('+OK 10 100')
81
82    def cmd_list(self, arg):
83        if arg:
84            self.push('+OK %s %s' %(arg, arg))
85        else:
86            self.push('+OK')
87            asynchat.async_chat.push(self, LIST_RESP)
88
89    cmd_uidl = cmd_list
90
91    def cmd_retr(self, arg):
92        self.push('+OK %s bytes' %len(RETR_RESP))
93        asynchat.async_chat.push(self, RETR_RESP)
94
95    cmd_top = cmd_retr
96
97    def cmd_dele(self, arg):
98        self.push('+OK message marked for deletion.')
99
100    def cmd_noop(self, arg):
101        self.push('+OK done nothing.')
102
103    def cmd_rpop(self, arg):
104        self.push('+OK done nothing.')
105
106
107class DummyPOP3Server(asyncore.dispatcher, threading.Thread):
108
109    handler = DummyPOP3Handler
110
111    def __init__(self, address, af=socket.AF_INET):
112        threading.Thread.__init__(self)
113        asyncore.dispatcher.__init__(self)
114        self.create_socket(af, socket.SOCK_STREAM)
115        self.bind(address)
116        self.listen(5)
117        self.active = False
118        self.active_lock = threading.Lock()
119        self.host, self.port = self.socket.getsockname()[:2]
120
121    def start(self):
122        assert not self.active
123        self.__flag = threading.Event()
124        threading.Thread.start(self)
125        self.__flag.wait()
126
127    def run(self):
128        self.active = True
129        self.__flag.set()
130        while self.active and asyncore.socket_map:
131            self.active_lock.acquire()
132            asyncore.loop(timeout=0.1, count=1)
133            self.active_lock.release()
134        asyncore.close_all(ignore_all=True)
135
136    def stop(self):
137        assert self.active
138        self.active = False
139        self.join()
140
141    def handle_accept(self):
142        conn, addr = self.accept()
143        self.handler = self.handler(conn)
144        self.close()
145
146    def handle_connect(self):
147        self.close()
148    handle_read = handle_connect
149
150    def writable(self):
151        return 0
152
153    def handle_error(self):
154        raise
155
156
157class TestPOP3Class(TestCase):
158
159    def assertOK(self, resp):
160        self.assertTrue(resp.startswith("+OK"))
161
162    def setUp(self):
163        self.server = DummyPOP3Server((HOST, 0))
164        self.server.start()
165        self.client = poplib.POP3(self.server.host, self.server.port)
166
167    def tearDown(self):
168        self.client.quit()
169        self.server.stop()
170
171    def test_getwelcome(self):
172        self.assertEqual(self.client.getwelcome(), '+OK dummy pop3 server ready.')
173
174    def test_exceptions(self):
175        self.assertRaises(poplib.error_proto, self.client._shortcmd, 'echo -err')
176
177    def test_user(self):
178        self.assertOK(self.client.user('guido'))
179        self.assertRaises(poplib.error_proto, self.client.user, 'invalid')
180
181    def test_pass_(self):
182        self.assertOK(self.client.pass_('python'))
183        self.assertRaises(poplib.error_proto, self.client.user, 'invalid')
184
185    def test_stat(self):
186        self.assertEqual(self.client.stat(), (10, 100))
187
188    def test_list(self):
189        self.assertEqual(self.client.list()[1:],
190                         (['1 1', '2 2', '3 3', '4 4', '5 5'], 25))
191        self.assertTrue(self.client.list('1').endswith("OK 1 1"))
192
193    def test_retr(self):
194        expected = ('+OK 116 bytes',
195                    ['From: [email protected]', 'Content-Type: text/plain',
196                     'MIME-Version: 1.0', 'Subject: Dummy',
197                     '', 'line1', 'line2', 'line3'],
198                    113)
199        self.assertEqual(self.client.retr('foo'), expected)
200
201    def test_too_long_lines(self):
202        self.assertRaises(poplib.error_proto, self.client._shortcmd,
203                          'echo +%s' % ((poplib._MAXLINE + 10) * 'a'))
204
205    def test_dele(self):
206        self.assertOK(self.client.dele('foo'))
207
208    def test_noop(self):
209        self.assertOK(self.client.noop())
210
211    def test_rpop(self):
212        self.assertOK(self.client.rpop('foo'))
213
214    def test_apop_REDOS(self):
215        # Replace welcome with very long evil welcome.
216        # NB The upper bound on welcome length is currently 2048.
217        # At this length, evil input makes each apop call take
218        # on the order of milliseconds instead of microseconds.
219        evil_welcome = b'+OK' + (b'<' * 1000000)
220        with test_support.swap_attr(self.client, 'welcome', evil_welcome):
221            # The evil welcome is invalid, so apop should throw.
222            self.assertRaises(poplib.error_proto, self.client.apop, 'a', 'kb')
223
224    def test_top(self):
225        expected =  ('+OK 116 bytes',
226                     ['From: [email protected]', 'Content-Type: text/plain',
227                      'MIME-Version: 1.0', 'Subject: Dummy', '',
228                      'line1', 'line2', 'line3'],
229                     113)
230        self.assertEqual(self.client.top(1, 1), expected)
231
232    def test_uidl(self):
233        self.client.uidl()
234        self.client.uidl('foo')
235
236
237SUPPORTS_SSL = False
238if hasattr(poplib, 'POP3_SSL'):
239    import ssl
240
241    SUPPORTS_SSL = True
242    CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "keycert.pem")
243
244    class DummyPOP3_SSLHandler(DummyPOP3Handler):
245
246        def __init__(self, conn):
247            asynchat.async_chat.__init__(self, conn)
248            self.socket = ssl.wrap_socket(self.socket, certfile=CERTFILE,
249                                          server_side=True,
250                                          do_handshake_on_connect=False)
251            # Must try handshake before calling push()
252            self._ssl_accepting = True
253            self._do_ssl_handshake()
254            self.set_terminator("\r\n")
255            self.in_buffer = []
256            self.push('+OK dummy pop3 server ready.')
257
258        def _do_ssl_handshake(self):
259            try:
260                self.socket.do_handshake()
261            except ssl.SSLError, err:
262                if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
263                                   ssl.SSL_ERROR_WANT_WRITE):
264                    return
265                elif err.args[0] == ssl.SSL_ERROR_EOF:
266                    return self.handle_close()
267                raise
268            except socket.error, err:
269                if err.args[0] == errno.ECONNABORTED:
270                    return self.handle_close()
271            else:
272                self._ssl_accepting = False
273
274        def handle_read(self):
275            if self._ssl_accepting:
276                self._do_ssl_handshake()
277            else:
278                DummyPOP3Handler.handle_read(self)
279
280requires_ssl = skipUnless(SUPPORTS_SSL, 'SSL not supported')
281
282@requires_ssl
283class TestPOP3_SSLClass(TestPOP3Class):
284    # repeat previous tests by using poplib.POP3_SSL
285
286    def setUp(self):
287        self.server = DummyPOP3Server((HOST, 0))
288        self.server.handler = DummyPOP3_SSLHandler
289        self.server.start()
290        self.client = poplib.POP3_SSL(self.server.host, self.server.port)
291
292    def test__all__(self):
293        self.assertIn('POP3_SSL', poplib.__all__)
294
295
296class TestTimeouts(TestCase):
297
298    def setUp(self):
299        self.evt = threading.Event()
300        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
301        self.sock.settimeout(60)  # Safety net. Look issue 11812
302        self.port = test_support.bind_port(self.sock)
303        self.thread = threading.Thread(target=self.server, args=(self.evt,self.sock))
304        self.thread.setDaemon(True)
305        self.thread.start()
306        self.evt.wait()
307
308    def tearDown(self):
309        self.thread.join()
310        del self.thread  # Clear out any dangling Thread objects.
311
312    def server(self, evt, serv):
313        serv.listen(5)
314        evt.set()
315        try:
316            conn, addr = serv.accept()
317            conn.send("+ Hola mundo\n")
318            conn.close()
319        except socket.timeout:
320            pass
321        finally:
322            serv.close()
323
324    def testTimeoutDefault(self):
325        self.assertIsNone(socket.getdefaulttimeout())
326        socket.setdefaulttimeout(30)
327        try:
328            pop = poplib.POP3(HOST, self.port)
329        finally:
330            socket.setdefaulttimeout(None)
331        self.assertEqual(pop.sock.gettimeout(), 30)
332        pop.sock.close()
333
334    def testTimeoutNone(self):
335        self.assertIsNone(socket.getdefaulttimeout())
336        socket.setdefaulttimeout(30)
337        try:
338            pop = poplib.POP3(HOST, self.port, timeout=None)
339        finally:
340            socket.setdefaulttimeout(None)
341        self.assertIsNone(pop.sock.gettimeout())
342        pop.sock.close()
343
344    def testTimeoutValue(self):
345        pop = poplib.POP3(HOST, self.port, timeout=30)
346        self.assertEqual(pop.sock.gettimeout(), 30)
347        pop.sock.close()
348
349
350def test_main():
351    tests = [TestPOP3Class, TestTimeouts,
352             TestPOP3_SSLClass]
353    thread_info = test_support.threading_setup()
354    try:
355        test_support.run_unittest(*tests)
356    finally:
357        test_support.threading_cleanup(*thread_info)
358
359
360if __name__ == '__main__':
361    test_main()
362