Merge heads

4 files changed, 182 insertions, 55 deletions

diff --git a/Lib/test/test_asyncio/test_base_events.py b/Lib/test/test_asyncio/test_base_events.py
index 9f36896fbf..9b883c5211 100644
--- a/Lib/test/test_asyncio/test_base_events.py
+++ b/Lib/test/test_asyncio/test_base_events.py
@@ -1,5 +1,6 @@
 """Tests for base_events.py"""
 
+import errno
 import logging
 import socket
 import time
@@ -8,6 +9,7 @@ import unittest.mock
 from test.support import find_unused_port, IPV6_ENABLED
 
 from asyncio import base_events
+from asyncio import constants
 from asyncio import events
 from asyncio import futures
 from asyncio import protocols
@@ -442,6 +444,71 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
         self.assertRaises(
             OSError, self.loop.run_until_complete, coro)
 
+    def test_create_connection_ssl_server_hostname_default(self):
+        self.loop.getaddrinfo = unittest.mock.Mock()
+
+        def mock_getaddrinfo(*args, **kwds):
+            f = futures.Future(loop=self.loop)
+            f.set_result([(socket.AF_INET, socket.SOCK_STREAM,
+                           socket.SOL_TCP, '', ('1.2.3.4', 80))])
+            return f
+
+        self.loop.getaddrinfo.side_effect = mock_getaddrinfo
+        self.loop.sock_connect = unittest.mock.Mock()
+        self.loop.sock_connect.return_value = ()
+        self.loop._make_ssl_transport = unittest.mock.Mock()
+
+        def mock_make_ssl_transport(sock, protocol, sslcontext, waiter,
+                                    **kwds):
+            waiter.set_result(None)
+
+        self.loop._make_ssl_transport.side_effect = mock_make_ssl_transport
+        ANY = unittest.mock.ANY
+        # First try the default server_hostname.
+        self.loop._make_ssl_transport.reset_mock()
+        coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True)
+        self.loop.run_until_complete(coro)
+        self.loop._make_ssl_transport.assert_called_with(
+            ANY, ANY, ANY, ANY,
+            server_side=False,
+            server_hostname='python.org')
+        # Next try an explicit server_hostname.
+        self.loop._make_ssl_transport.reset_mock()
+        coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True,
+                                           server_hostname='perl.com')
+        self.loop.run_until_complete(coro)
+        self.loop._make_ssl_transport.assert_called_with(
+            ANY, ANY, ANY, ANY,
+            server_side=False,
+            server_hostname='perl.com')
+        # Finally try an explicit empty server_hostname.
+        self.loop._make_ssl_transport.reset_mock()
+        coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True,
+                                           server_hostname='')
+        self.loop.run_until_complete(coro)
+        self.loop._make_ssl_transport.assert_called_with(ANY, ANY, ANY, ANY,
+                                                         server_side=False,
+                                                         server_hostname='')
+
+    def test_create_connection_no_ssl_server_hostname_errors(self):
+        # When not using ssl, server_hostname must be None.
+        coro = self.loop.create_connection(MyProto, 'python.org', 80,
+                                           server_hostname='')
+        self.assertRaises(ValueError, self.loop.run_until_complete, coro)
+        coro = self.loop.create_connection(MyProto, 'python.org', 80,
+                                           server_hostname='python.org')
+        self.assertRaises(ValueError, self.loop.run_until_complete, coro)
+
+    def test_create_connection_ssl_server_hostname_errors(self):
+        # When using ssl, server_hostname may be None if host is non-empty.
+        coro = self.loop.create_connection(MyProto, '', 80, ssl=True)
+        self.assertRaises(ValueError, self.loop.run_until_complete, coro)
+        coro = self.loop.create_connection(MyProto, None, 80, ssl=True)
+        self.assertRaises(ValueError, self.loop.run_until_complete, coro)
+        coro = self.loop.create_connection(MyProto, None, None,
+                                           ssl=True, sock=socket.socket())
+        self.assertRaises(ValueError, self.loop.run_until_complete, coro)
+
     def test_create_server_empty_host(self):
         # if host is empty string use None instead
         host = object()
@@ -585,11 +652,18 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
     def test_accept_connection_exception(self, m_log):
         sock = unittest.mock.Mock()
         sock.fileno.return_value = 10
-        sock.accept.side_effect = OSError()
+        sock.accept.side_effect = OSError(errno.EMFILE, 'Too many open files')
+        self.loop.remove_reader = unittest.mock.Mock()
+        self.loop.call_later = unittest.mock.Mock()
 
         self.loop._accept_connection(MyProto, sock)
-        self.assertTrue(sock.close.called)
         self.assertTrue(m_log.exception.called)
+        self.assertFalse(sock.close.called)
+        self.loop.remove_reader.assert_called_with(10)
+        self.loop.call_later.assert_called_with(constants.ACCEPT_RETRY_DELAY,
+                                                # self.loop._start_serving
+                                                unittest.mock.ANY,
+                                                MyProto, sock, None, None)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_asyncio/test_events.py b/Lib/test/test_asyncio/test_events.py
index fd2af2e1eb..1288941996 100644
--- a/Lib/test/test_asyncio/test_events.py
+++ b/Lib/test/test_asyncio/test_events.py
@@ -1276,7 +1276,6 @@ if sys.platform == 'win32':
         def create_event_loop(self):
             return windows_events.SelectorEventLoop()
 
-
     class ProactorEventLoopTests(EventLoopTestsMixin,
                                  SubprocessTestsMixin,
                                  unittest.TestCase):
@@ -1472,6 +1471,8 @@ class AbstractEventLoopTests(unittest.TestCase):
         self.assertRaises(
             NotImplementedError, loop.is_running)
         self.assertRaises(
+            NotImplementedError, loop.close)
+        self.assertRaises(
             NotImplementedError, loop.call_later, None, None)
         self.assertRaises(
             NotImplementedError, loop.call_at, f, f)
diff --git a/Lib/test/test_asyncio/test_selector_events.py b/Lib/test/test_asyncio/test_selector_events.py
index fbd5d723d5..04a7d0c54d 100644
--- a/Lib/test/test_asyncio/test_selector_events.py
+++ b/Lib/test/test_asyncio/test_selector_events.py
@@ -43,6 +43,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
         self.assertIsInstance(
             self.loop._make_socket_transport(m, m), _SelectorSocketTransport)
 
+    @unittest.skipIf(ssl is None, 'No ssl module')
     def test_make_ssl_transport(self):
         m = unittest.mock.Mock()
         self.loop.add_reader = unittest.mock.Mock()
@@ -52,6 +53,16 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
         self.assertIsInstance(
             self.loop._make_ssl_transport(m, m, m, m), _SelectorSslTransport)
 
+    @unittest.mock.patch('asyncio.selector_events.ssl', None)
+    def test_make_ssl_transport_without_ssl_error(self):
+        m = unittest.mock.Mock()
+        self.loop.add_reader = unittest.mock.Mock()
+        self.loop.add_writer = unittest.mock.Mock()
+        self.loop.remove_reader = unittest.mock.Mock()
+        self.loop.remove_writer = unittest.mock.Mock()
+        with self.assertRaises(RuntimeError):
+            self.loop._make_ssl_transport(m, m, m, m)
+
     def test_close(self):
         ssock = self.loop._ssock
         ssock.fileno.return_value = 7
@@ -1003,8 +1014,7 @@ class SelectorSslTransportTests(unittest.TestCase):
             self.loop, self.sock, self.protocol, self.sslcontext,
             waiter=waiter)
         self.assertTrue(self.sslsock.do_handshake.called)
-        self.loop.assert_reader(1, tr._on_ready)
-        self.loop.assert_writer(1, tr._on_ready)
+        self.loop.assert_reader(1, tr._read_ready)
         test_utils.run_briefly(self.loop)
         self.assertIsNone(waiter.result())
 
@@ -1047,13 +1057,13 @@ class SelectorSslTransportTests(unittest.TestCase):
     def test_pause_resume_reading(self):
         tr = self._make_one()
         self.assertFalse(tr._paused)
-        self.loop.assert_reader(1, tr._on_ready)
+        self.loop.assert_reader(1, tr._read_ready)
         tr.pause_reading()
         self.assertTrue(tr._paused)
         self.assertFalse(1 in self.loop.readers)
         tr.resume_reading()
         self.assertFalse(tr._paused)
-        self.loop.assert_reader(1, tr._on_ready)
+        self.loop.assert_reader(1, tr._read_ready)
 
     def test_write_no_data(self):
         transport = self._make_one()
@@ -1084,140 +1094,173 @@ class SelectorSslTransportTests(unittest.TestCase):
         transport.write(b'data')
         m_log.warning.assert_called_with('socket.send() raised exception.')
 
-    def test_on_ready_recv(self):
+    def test_read_ready_recv(self):
         self.sslsock.recv.return_value = b'data'
         transport = self._make_one()
-        transport._on_ready()
+        transport._read_ready()
         self.assertTrue(self.sslsock.recv.called)
         self.assertEqual((b'data',), self.protocol.data_received.call_args[0])
 
-    def test_on_ready_recv_eof(self):
+    def test_read_ready_write_wants_read(self):
+        self.loop.add_writer = unittest.mock.Mock()
+        self.sslsock.recv.side_effect = BlockingIOError
+        transport = self._make_one()
+        transport._write_wants_read = True
+        transport._write_ready = unittest.mock.Mock()
+        transport._buffer.append(b'data')
+        transport._read_ready()
+
+        self.assertFalse(transport._write_wants_read)
+        transport._write_ready.assert_called_with()
+        self.loop.add_writer.assert_called_with(
+            transport._sock_fd, transport._write_ready)
+
+    def test_read_ready_recv_eof(self):
         self.sslsock.recv.return_value = b''
         transport = self._make_one()
         transport.close = unittest.mock.Mock()
-        transport._on_ready()
+        transport._read_ready()
         transport.close.assert_called_with()
         self.protocol.eof_received.assert_called_with()
 
-    def test_on_ready_recv_conn_reset(self):
+    def test_read_ready_recv_conn_reset(self):
         err = self.sslsock.recv.side_effect = ConnectionResetError()
         transport = self._make_one()
         transport._force_close = unittest.mock.Mock()
-        transport._on_ready()
+        transport._read_ready()
         transport._force_close.assert_called_with(err)
 
-    def test_on_ready_recv_retry(self):
+    def test_read_ready_recv_retry(self):
         self.sslsock.recv.side_effect = ssl.SSLWantReadError
         transport = self._make_one()
-        transport._on_ready()
+        transport._read_ready()
         self.assertTrue(self.sslsock.recv.called)
         self.assertFalse(self.protocol.data_received.called)
 
-        self.sslsock.recv.side_effect = ssl.SSLWantWriteError
-        transport._on_ready()
-        self.assertFalse(self.protocol.data_received.called)
-
         self.sslsock.recv.side_effect = BlockingIOError
-        transport._on_ready()
+        transport._read_ready()
         self.assertFalse(self.protocol.data_received.called)
 
         self.sslsock.recv.side_effect = InterruptedError
-        transport._on_ready()
+        transport._read_ready()
         self.assertFalse(self.protocol.data_received.called)
 
-    def test_on_ready_recv_exc(self):
+    def test_read_ready_recv_write(self):
+        self.loop.remove_reader = unittest.mock.Mock()
+        self.loop.add_writer = unittest.mock.Mock()
+        self.sslsock.recv.side_effect = ssl.SSLWantWriteError
+        transport = self._make_one()
+        transport._read_ready()
+        self.assertFalse(self.protocol.data_received.called)
+        self.assertTrue(transport._read_wants_write)
+
+        self.loop.remove_reader.assert_called_with(transport._sock_fd)
+        self.loop.add_writer.assert_called_with(
+            transport._sock_fd, transport._write_ready)
+
+    def test_read_ready_recv_exc(self):
         err = self.sslsock.recv.side_effect = OSError()
         transport = self._make_one()
         transport._fatal_error = unittest.mock.Mock()
-        transport._on_ready()
+        transport._read_ready()
         transport._fatal_error.assert_called_with(err)
 
-    def test_on_ready_send(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send(self):
         self.sslsock.send.return_value = 4
         transport = self._make_one()
         transport._buffer = collections.deque([b'data'])
-        transport._on_ready()
+        transport._write_ready()
         self.assertEqual(collections.deque(), transport._buffer)
         self.assertTrue(self.sslsock.send.called)
 
-    def test_on_ready_send_none(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send_none(self):
         self.sslsock.send.return_value = 0
         transport = self._make_one()
         transport._buffer = collections.deque([b'data1', b'data2'])
-        transport._on_ready()
+        transport._write_ready()
         self.assertTrue(self.sslsock.send.called)
         self.assertEqual(collections.deque([b'data1data2']), transport._buffer)
 
-    def test_on_ready_send_partial(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send_partial(self):
         self.sslsock.send.return_value = 2
         transport = self._make_one()
         transport._buffer = collections.deque([b'data1', b'data2'])
-        transport._on_ready()
+        transport._write_ready()
         self.assertTrue(self.sslsock.send.called)
         self.assertEqual(collections.deque([b'ta1data2']), transport._buffer)
 
-    def test_on_ready_send_closing_partial(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send_closing_partial(self):
         self.sslsock.send.return_value = 2
         transport = self._make_one()
         transport._buffer = collections.deque([b'data1', b'data2'])
-        transport._on_ready()
+        transport._write_ready()
         self.assertTrue(self.sslsock.send.called)
         self.assertFalse(self.sslsock.close.called)
 
-    def test_on_ready_send_closing(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send_closing(self):
         self.sslsock.send.return_value = 4
         transport = self._make_one()
         transport.close()
         transport._buffer = collections.deque([b'data'])
-        transport._on_ready()
+        transport._write_ready()
         self.assertFalse(self.loop.writers)
         self.protocol.connection_lost.assert_called_with(None)
 
-    def test_on_ready_send_closing_empty_buffer(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send_closing_empty_buffer(self):
         self.sslsock.send.return_value = 4
         transport = self._make_one()
         transport.close()
         transport._buffer = collections.deque()
-        transport._on_ready()
+        transport._write_ready()
         self.assertFalse(self.loop.writers)
         self.protocol.connection_lost.assert_called_with(None)
 
-    def test_on_ready_send_retry(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
-
+    def test_write_ready_send_retry(self):
         transport = self._make_one()
         transport._buffer = collections.deque([b'data'])
 
-        self.sslsock.send.side_effect = ssl.SSLWantReadError
-        transport._on_ready()
-        self.assertTrue(self.sslsock.send.called)
-        self.assertEqual(collections.deque([b'data']), transport._buffer)
-
         self.sslsock.send.side_effect = ssl.SSLWantWriteError
-        transport._on_ready()
+        transport._write_ready()
         self.assertEqual(collections.deque([b'data']), transport._buffer)
 
         self.sslsock.send.side_effect = BlockingIOError()
-        transport._on_ready()
+        transport._write_ready()
         self.assertEqual(collections.deque([b'data']), transport._buffer)
 
-    def test_on_ready_send_exc(self):
-        self.sslsock.recv.side_effect = ssl.SSLWantReadError
+    def test_write_ready_send_read(self):
+        transport = self._make_one()
+        transport._buffer = collections.deque([b'data'])
+
+        self.loop.remove_writer = unittest.mock.Mock()
+        self.sslsock.send.side_effect = ssl.SSLWantReadError
+        transport._write_ready()
+        self.assertFalse(self.protocol.data_received.called)
+        self.assertTrue(transport._write_wants_read)
+        self.loop.remove_writer.assert_called_with(transport._sock_fd)
+
+    def test_write_ready_send_exc(self):
         err = self.sslsock.send.side_effect = OSError()
 
         transport = self._make_one()
         transport._buffer = collections.deque([b'data'])
         transport._fatal_error = unittest.mock.Mock()
-        transport._on_ready()
+        transport._write_ready()
         transport._fatal_error.assert_called_with(err)
         self.assertEqual(collections.deque(), transport._buffer)
 
+    def test_write_ready_read_wants_write(self):
+        self.loop.add_reader = unittest.mock.Mock()
+        self.sslsock.send.side_effect = BlockingIOError
+        transport = self._make_one()
+        transport._read_wants_write = True
+        transport._read_ready = unittest.mock.Mock()
+        transport._write_ready()
+
+        self.assertFalse(transport._read_wants_write)
+        transport._read_ready.assert_called_with()
+        self.loop.add_reader.assert_called_with(
+            transport._sock_fd, transport._read_ready)
+
     def test_write_eof(self):
         tr = self._make_one()
         self.assertFalse(tr.can_write_eof())
@@ -1245,6 +1288,15 @@ class SelectorSslTransportTests(unittest.TestCase):
             server_hostname='localhost')
 
 
+class SelectorSslWithoutSslTransportTests(unittest.TestCase):
+
+    @unittest.mock.patch('asyncio.selector_events.ssl', None)
+    def test_ssl_transport_requires_ssl_module(self):
+        Mock = unittest.mock.Mock
+        with self.assertRaises(RuntimeError):
+            transport = _SelectorSslTransport(Mock(), Mock(), Mock(), Mock())
+
+
 class SelectorDatagramTransportTests(unittest.TestCase):
 
     def setUp(self):
diff --git a/Lib/test/test_asyncio/test_windows_events.py b/Lib/test/test_asyncio/test_windows_events.py
index 553ea34345..f5147de25d 100644
--- a/Lib/test/test_asyncio/test_windows_events.py
+++ b/Lib/test/test_asyncio/test_windows_events.py
@@ -77,7 +77,7 @@ class ProactorTests(unittest.TestCase):
             stream_reader = streams.StreamReader(loop=self.loop)
             protocol = streams.StreamReaderProtocol(stream_reader)
             trans, proto = yield from self.loop.create_pipe_connection(
-                lambda:protocol, ADDRESS)
+                lambda: protocol, ADDRESS)
             self.assertIsInstance(trans, transports.Transport)
             self.assertEqual(protocol, proto)
             clients.append((stream_reader, trans))