mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-09-27 10:50:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 13

asyncio: Replace "unittest.mock" with "mock" in unit tests

Browse source 
Use "from unittest import mock". It should simplify my work to merge new tests
in Trollius, because Trollius uses "mock" backport for Python 2.
This commit is contained in:
Victor Stinner 2014-02-26 10:25:02 +01:00
parent 71ec82a501
commit 24ba203504
12 changed files with 368 additions and 368 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Lib/asyncio/test_utils.py
View file

@ -12,7 +12,7 @@ import tempfile
import threading import threading
import time import time
import unittest import unittest
import unittest.mock from unittest import mock
from http.server import HTTPServer from http.server import HTTPServer
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
@ -362,7 +362,7 @@ class TestLoop(base_events.BaseEventLoop):
def MockCallback(**kwargs): def MockCallback(**kwargs):
return unittest.mock.Mock(spec=['__call__'], **kwargs) return mock.Mock(spec=['__call__'], **kwargs)
class MockPattern(str): class MockPattern(str):

108
Lib/test/test_asyncio/test_base_events.py
View file

@ -6,7 +6,7 @@ import socket
import sys import sys
import time import time
import unittest import unittest
import unittest.mock from unittest import mock
from test.support import find_unused_port, IPV6_ENABLED from test.support import find_unused_port, IPV6_ENABLED
import asyncio import asyncio
@ -15,7 +15,7 @@ from asyncio import constants
from asyncio import test_utils from asyncio import test_utils
MOCK_ANY = unittest.mock.ANY MOCK_ANY = mock.ANY
PY34 = sys.version_info >= (3, 4) PY34 = sys.version_info >= (3, 4)
@ -23,11 +23,11 @@ class BaseEventLoopTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = base_events.BaseEventLoop() self.loop = base_events.BaseEventLoop()
self.loop._selector = unittest.mock.Mock() self.loop._selector = mock.Mock()
asyncio.set_event_loop(None) asyncio.set_event_loop(None)
def test_not_implemented(self): def test_not_implemented(self):
m = unittest.mock.Mock() m = mock.Mock()
self.assertRaises( self.assertRaises(
NotImplementedError, NotImplementedError,
self.loop._make_socket_transport, m, m) self.loop._make_socket_transport, m, m)
@ -75,13 +75,13 @@ class BaseEventLoopTests(unittest.TestCase):
self.assertFalse(self.loop._ready) self.assertFalse(self.loop._ready)
def test_set_default_executor(self): def test_set_default_executor(self):
executor = unittest.mock.Mock() executor = mock.Mock()
self.loop.set_default_executor(executor) self.loop.set_default_executor(executor)
self.assertIs(executor, self.loop._default_executor) self.assertIs(executor, self.loop._default_executor)
def test_getnameinfo(self): def test_getnameinfo(self):
sockaddr = unittest.mock.Mock() sockaddr = mock.Mock()
self.loop.run_in_executor = unittest.mock.Mock() self.loop.run_in_executor = mock.Mock()
self.loop.getnameinfo(sockaddr) self.loop.getnameinfo(sockaddr)
self.assertEqual( self.assertEqual(
(None, socket.getnameinfo, sockaddr, 0), (None, socket.getnameinfo, sockaddr, 0),
@ -111,7 +111,7 @@ class BaseEventLoopTests(unittest.TestCase):
def cb(arg): def cb(arg):
calls.append(arg) calls.append(arg)
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop.call_later(-1, cb, 'a') self.loop.call_later(-1, cb, 'a')
self.loop.call_later(-2, cb, 'b') self.loop.call_later(-2, cb, 'b')
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
@ -121,7 +121,7 @@ class BaseEventLoopTests(unittest.TestCase):
def cb(): def cb():
self.loop.stop() self.loop.stop()
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
delay = 0.1 delay = 0.1
when = self.loop.time() + delay when = self.loop.time() + delay
@ -163,7 +163,7 @@ class BaseEventLoopTests(unittest.TestCase):
pass pass
h = asyncio.Handle(cb, (), self.loop) h = asyncio.Handle(cb, (), self.loop)
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
executor = unittest.mock.Mock() executor = mock.Mock()
executor.submit.return_value = f executor.submit.return_value = f
self.loop.set_default_executor(executor) self.loop.set_default_executor(executor)
@ -171,7 +171,7 @@ class BaseEventLoopTests(unittest.TestCase):
res = self.loop.run_in_executor(None, h) res = self.loop.run_in_executor(None, h)
self.assertIs(f, res) self.assertIs(f, res)
executor = unittest.mock.Mock() executor = mock.Mock()
executor.submit.return_value = f executor.submit.return_value = f
res = self.loop.run_in_executor(executor, h) res = self.loop.run_in_executor(executor, h)
self.assertIs(f, res) self.assertIs(f, res)
@ -187,7 +187,7 @@ class BaseEventLoopTests(unittest.TestCase):
h1.cancel() h1.cancel()
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop._scheduled.append(h1) self.loop._scheduled.append(h1)
self.loop._scheduled.append(h2) self.loop._scheduled.append(h2)
self.loop._run_once() self.loop._run_once()
@ -203,8 +203,8 @@ class BaseEventLoopTests(unittest.TestCase):
self.loop.set_debug(False) self.loop.set_debug(False)
self.assertFalse(self.loop.get_debug()) self.assertFalse(self.loop.get_debug())
@unittest.mock.patch('asyncio.base_events.time') @mock.patch('asyncio.base_events.time')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test__run_once_logging(self, m_logger, m_time): def test__run_once_logging(self, m_logger, m_time):
# Log to INFO level if timeout > 1.0 sec. # Log to INFO level if timeout > 1.0 sec.
idx = -1 idx = -1
@ -219,7 +219,7 @@ class BaseEventLoopTests(unittest.TestCase):
self.loop._scheduled.append( self.loop._scheduled.append(
asyncio.TimerHandle(11.0, lambda: True, (), self.loop)) asyncio.TimerHandle(11.0, lambda: True, (), self.loop))
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop._run_once() self.loop._run_once()
self.assertEqual(logging.INFO, m_logger.log.call_args[0][0]) self.assertEqual(logging.INFO, m_logger.log.call_args[0][0])
@ -242,7 +242,7 @@ class BaseEventLoopTests(unittest.TestCase):
h = asyncio.TimerHandle(time.monotonic() - 1, cb, (self.loop,), h = asyncio.TimerHandle(time.monotonic() - 1, cb, (self.loop,),
self.loop) self.loop)
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop._scheduled.append(h) self.loop._scheduled.append(h)
self.loop._run_once() self.loop._run_once()
@ -303,14 +303,14 @@ class BaseEventLoopTests(unittest.TestCase):
asyncio.SubprocessProtocol, 'exit 0', bufsize=4096) asyncio.SubprocessProtocol, 'exit 0', bufsize=4096)
def test_default_exc_handler_callback(self): def test_default_exc_handler_callback(self):
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
def zero_error(fut): def zero_error(fut):
fut.set_result(True) fut.set_result(True)
1/0 1/0
# Test call_soon (events.Handle) # Test call_soon (events.Handle)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
self.loop.call_soon(zero_error, fut) self.loop.call_soon(zero_error, fut)
fut.add_done_callback(lambda fut: self.loop.stop()) fut.add_done_callback(lambda fut: self.loop.stop())
@ -320,7 +320,7 @@ class BaseEventLoopTests(unittest.TestCase):
exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY)) exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))
# Test call_later (events.TimerHandle) # Test call_later (events.TimerHandle)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
self.loop.call_later(0.01, zero_error, fut) self.loop.call_later(0.01, zero_error, fut)
fut.add_done_callback(lambda fut: self.loop.stop()) fut.add_done_callback(lambda fut: self.loop.stop())
@ -330,7 +330,7 @@ class BaseEventLoopTests(unittest.TestCase):
exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY)) exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))
def test_default_exc_handler_coro(self): def test_default_exc_handler_coro(self):
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
@asyncio.coroutine @asyncio.coroutine
def zero_error_coro(): def zero_error_coro():
@ -338,7 +338,7 @@ class BaseEventLoopTests(unittest.TestCase):
1/0 1/0
# Test Future.__del__ # Test Future.__del__
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
fut = asyncio.async(zero_error_coro(), loop=self.loop) fut = asyncio.async(zero_error_coro(), loop=self.loop)
fut.add_done_callback(lambda *args: self.loop.stop()) fut.add_done_callback(lambda *args: self.loop.stop())
self.loop.run_forever() self.loop.run_forever()
@ -368,9 +368,9 @@ class BaseEventLoopTests(unittest.TestCase):
self.loop.call_soon(zero_error) self.loop.call_soon(zero_error)
self.loop._run_once() self.loop._run_once()
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
mock_handler = unittest.mock.Mock() mock_handler = mock.Mock()
self.loop.set_exception_handler(mock_handler) self.loop.set_exception_handler(mock_handler)
run_loop() run_loop()
mock_handler.assert_called_with(self.loop, { mock_handler.assert_called_with(self.loop, {
@ -382,7 +382,7 @@ class BaseEventLoopTests(unittest.TestCase):
mock_handler.reset_mock() mock_handler.reset_mock()
self.loop.set_exception_handler(None) self.loop.set_exception_handler(None)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
test_utils.MockPattern( test_utils.MockPattern(
@ -401,11 +401,11 @@ class BaseEventLoopTests(unittest.TestCase):
def handler(loop, context): def handler(loop, context):
raise AttributeError('spam') raise AttributeError('spam')
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop.set_exception_handler(handler) self.loop.set_exception_handler(handler)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
test_utils.MockPattern( test_utils.MockPattern(
@ -417,8 +417,8 @@ class BaseEventLoopTests(unittest.TestCase):
class Loop(base_events.BaseEventLoop): class Loop(base_events.BaseEventLoop):
_selector = unittest.mock.Mock() _selector = mock.Mock()
_process_events = unittest.mock.Mock() _process_events = mock.Mock()
def default_exception_handler(self, context): def default_exception_handler(self, context):
nonlocal _context nonlocal _context
@ -435,7 +435,7 @@ class BaseEventLoopTests(unittest.TestCase):
loop.call_soon(zero_error) loop.call_soon(zero_error)
loop._run_once() loop._run_once()
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
'Exception in default exception handler', 'Exception in default exception handler',
@ -446,7 +446,7 @@ class BaseEventLoopTests(unittest.TestCase):
_context = None _context = None
loop.set_exception_handler(custom_handler) loop.set_exception_handler(custom_handler)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
test_utils.MockPattern('Exception in default exception.*' test_utils.MockPattern('Exception in default exception.*'
@ -527,7 +527,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
def tearDown(self): def tearDown(self):
self.loop.close() self.loop.close()
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_connection_multiple_errors(self, m_socket): def test_create_connection_multiple_errors(self, m_socket):
class MyProto(asyncio.Protocol): class MyProto(asyncio.Protocol):
@ -592,7 +592,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop) return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
self.loop.getaddrinfo = getaddrinfo_task self.loop.getaddrinfo = getaddrinfo_task
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError self.loop.sock_connect.side_effect = OSError
coro = self.loop.create_connection(MyProto, 'example.com', 80) coro = self.loop.create_connection(MyProto, 'example.com', 80)
@ -609,7 +609,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop) return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
self.loop.getaddrinfo = getaddrinfo_task self.loop.getaddrinfo = getaddrinfo_task
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError self.loop.sock_connect.side_effect = OSError
coro = self.loop.create_connection( coro = self.loop.create_connection(
@ -617,7 +617,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
with self.assertRaises(OSError): with self.assertRaises(OSError):
self.loop.run_until_complete(coro) self.loop.run_until_complete(coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_connection_multiple_errors_local_addr(self, m_socket): def test_create_connection_multiple_errors_local_addr(self, m_socket):
def bind(addr): def bind(addr):
@ -637,7 +637,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop) return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
self.loop.getaddrinfo = getaddrinfo_task self.loop.getaddrinfo = getaddrinfo_task
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError('Err2') self.loop.sock_connect.side_effect = OSError('Err2')
coro = self.loop.create_connection( coro = self.loop.create_connection(
@ -669,7 +669,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
OSError, self.loop.run_until_complete, coro) OSError, self.loop.run_until_complete, coro)
def test_create_connection_ssl_server_hostname_default(self): def test_create_connection_ssl_server_hostname_default(self):
self.loop.getaddrinfo = unittest.mock.Mock() self.loop.getaddrinfo = mock.Mock()
def mock_getaddrinfo(*args, **kwds): def mock_getaddrinfo(*args, **kwds):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
@ -678,9 +678,9 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
return f return f
self.loop.getaddrinfo.side_effect = mock_getaddrinfo self.loop.getaddrinfo.side_effect = mock_getaddrinfo
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.return_value = () self.loop.sock_connect.return_value = ()
self.loop._make_ssl_transport = unittest.mock.Mock() self.loop._make_ssl_transport = mock.Mock()
class _SelectorTransportMock: class _SelectorTransportMock:
_sock = None _sock = None
@ -696,7 +696,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
return transport return transport
self.loop._make_ssl_transport.side_effect = mock_make_ssl_transport self.loop._make_ssl_transport.side_effect = mock_make_ssl_transport
ANY = unittest.mock.ANY ANY = mock.ANY
# First try the default server_hostname. # First try the default server_hostname.
self.loop._make_ssl_transport.reset_mock() self.loop._make_ssl_transport.reset_mock()
coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True) coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True)
@ -775,13 +775,13 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
self.assertRaises(ValueError, self.loop.run_until_complete, fut) self.assertRaises(ValueError, self.loop.run_until_complete, fut)
def test_create_server_no_getaddrinfo(self): def test_create_server_no_getaddrinfo(self):
getaddrinfo = self.loop.getaddrinfo = unittest.mock.Mock() getaddrinfo = self.loop.getaddrinfo = mock.Mock()
getaddrinfo.return_value = [] getaddrinfo.return_value = []
f = self.loop.create_server(MyProto, '0.0.0.0', 0) f = self.loop.create_server(MyProto, '0.0.0.0', 0)
self.assertRaises(OSError, self.loop.run_until_complete, f) self.assertRaises(OSError, self.loop.run_until_complete, f)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_server_cant_bind(self, m_socket): def test_create_server_cant_bind(self, m_socket):
class Err(OSError): class Err(OSError):
@ -790,14 +790,14 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
m_socket.getaddrinfo.return_value = [ m_socket.getaddrinfo.return_value = [
(2, 1, 6, '', ('127.0.0.1', 10100))] (2, 1, 6, '', ('127.0.0.1', 10100))]
m_socket.getaddrinfo._is_coroutine = False m_socket.getaddrinfo._is_coroutine = False
m_sock = m_socket.socket.return_value = unittest.mock.Mock() m_sock = m_socket.socket.return_value = mock.Mock()
m_sock.bind.side_effect = Err m_sock.bind.side_effect = Err
fut = self.loop.create_server(MyProto, '0.0.0.0', 0) fut = self.loop.create_server(MyProto, '0.0.0.0', 0)
self.assertRaises(OSError, self.loop.run_until_complete, fut) self.assertRaises(OSError, self.loop.run_until_complete, fut)
self.assertTrue(m_sock.close.called) self.assertTrue(m_sock.close.called)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_no_addrinfo(self, m_socket): def test_create_datagram_endpoint_no_addrinfo(self, m_socket):
m_socket.getaddrinfo.return_value = [] m_socket.getaddrinfo.return_value = []
m_socket.getaddrinfo._is_coroutine = False m_socket.getaddrinfo._is_coroutine = False
@ -818,7 +818,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
AssertionError, self.loop.run_until_complete, coro) AssertionError, self.loop.run_until_complete, coro)
def test_create_datagram_endpoint_connect_err(self): def test_create_datagram_endpoint_connect_err(self):
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError self.loop.sock_connect.side_effect = OSError
coro = self.loop.create_datagram_endpoint( coro = self.loop.create_datagram_endpoint(
@ -826,7 +826,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
self.assertRaises( self.assertRaises(
OSError, self.loop.run_until_complete, coro) OSError, self.loop.run_until_complete, coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_socket_err(self, m_socket): def test_create_datagram_endpoint_socket_err(self, m_socket):
m_socket.getaddrinfo = socket.getaddrinfo m_socket.getaddrinfo = socket.getaddrinfo
m_socket.socket.side_effect = OSError m_socket.socket.side_effect = OSError
@ -849,7 +849,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
self.assertRaises( self.assertRaises(
ValueError, self.loop.run_until_complete, coro) ValueError, self.loop.run_until_complete, coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_setblk_err(self, m_socket): def test_create_datagram_endpoint_setblk_err(self, m_socket):
m_socket.socket.return_value.setblocking.side_effect = OSError m_socket.socket.return_value.setblocking.side_effect = OSError
@ -865,14 +865,14 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
asyncio.DatagramProtocol) asyncio.DatagramProtocol)
self.assertRaises(ValueError, self.loop.run_until_complete, coro) self.assertRaises(ValueError, self.loop.run_until_complete, coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_cant_bind(self, m_socket): def test_create_datagram_endpoint_cant_bind(self, m_socket):
class Err(OSError): class Err(OSError):
pass pass
m_socket.AF_INET6 = socket.AF_INET6 m_socket.AF_INET6 = socket.AF_INET6
m_socket.getaddrinfo = socket.getaddrinfo m_socket.getaddrinfo = socket.getaddrinfo
m_sock = m_socket.socket.return_value = unittest.mock.Mock() m_sock = m_socket.socket.return_value = mock.Mock()
m_sock.bind.side_effect = Err m_sock.bind.side_effect = Err
fut = self.loop.create_datagram_endpoint( fut = self.loop.create_datagram_endpoint(
@ -882,19 +882,19 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
self.assertTrue(m_sock.close.called) self.assertTrue(m_sock.close.called)
def test_accept_connection_retry(self): def test_accept_connection_retry(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.accept.side_effect = BlockingIOError() sock.accept.side_effect = BlockingIOError()
self.loop._accept_connection(MyProto, sock) self.loop._accept_connection(MyProto, sock)
self.assertFalse(sock.close.called) self.assertFalse(sock.close.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_accept_connection_exception(self, m_log): def test_accept_connection_exception(self, m_log):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.accept.side_effect = OSError(errno.EMFILE, 'Too many open files') sock.accept.side_effect = OSError(errno.EMFILE, 'Too many open files')
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.call_later = unittest.mock.Mock() self.loop.call_later = mock.Mock()
self.loop._accept_connection(MyProto, sock) self.loop._accept_connection(MyProto, sock)
self.assertTrue(m_log.error.called) self.assertTrue(m_log.error.called)
@ -902,7 +902,7 @@ class BaseEventLoopWithSelectorTests(unittest.TestCase):
self.loop.remove_reader.assert_called_with(10) self.loop.remove_reader.assert_called_with(10)
self.loop.call_later.assert_called_with(constants.ACCEPT_RETRY_DELAY, self.loop.call_later.assert_called_with(constants.ACCEPT_RETRY_DELAY,
# self.loop._start_serving # self.loop._start_serving
unittest.mock.ANY, mock.ANY,
MyProto, sock, None, None) MyProto, sock, None, None)
def test_call_coroutine(self): def test_call_coroutine(self):

32
Lib/test/test_asyncio/test_events.py
View file

@ -20,7 +20,7 @@ import threading
import time import time
import errno import errno
import unittest import unittest
import unittest.mock from unittest import mock
from test import support # find_unused_port, IPV6_ENABLED, TEST_HOME_DIR from test import support # find_unused_port, IPV6_ENABLED, TEST_HOME_DIR
@ -1812,7 +1812,7 @@ class HandleTests(unittest.TestCase):
return args return args
args = () args = ()
h = asyncio.Handle(callback, args, unittest.mock.Mock()) h = asyncio.Handle(callback, args, mock.Mock())
self.assertIs(h._callback, callback) self.assertIs(h._callback, callback)
self.assertIs(h._args, args) self.assertIs(h._args, args)
self.assertFalse(h._cancelled) self.assertFalse(h._cancelled)
@ -1844,15 +1844,15 @@ class HandleTests(unittest.TestCase):
def callback(): def callback():
raise ValueError() raise ValueError()
m_loop = unittest.mock.Mock() m_loop = mock.Mock()
m_loop.call_exception_handler = unittest.mock.Mock() m_loop.call_exception_handler = mock.Mock()
h = asyncio.Handle(callback, (), m_loop) h = asyncio.Handle(callback, (), m_loop)
h._run() h._run()
m_loop.call_exception_handler.assert_called_with({ m_loop.call_exception_handler.assert_called_with({
'message': test_utils.MockPattern('Exception in callback.*'), 'message': test_utils.MockPattern('Exception in callback.*'),
'exception': unittest.mock.ANY, 'exception': mock.ANY,
'handle': h 'handle': h
}) })
@ -1862,7 +1862,7 @@ class TimerTests(unittest.TestCase):
def test_hash(self): def test_hash(self):
when = time.monotonic() when = time.monotonic()
h = asyncio.TimerHandle(when, lambda: False, (), h = asyncio.TimerHandle(when, lambda: False, (),
unittest.mock.Mock()) mock.Mock())
self.assertEqual(hash(h), hash(when)) self.assertEqual(hash(h), hash(when))
def test_timer(self): def test_timer(self):
@ -1871,7 +1871,7 @@ class TimerTests(unittest.TestCase):
args = () args = ()
when = time.monotonic() when = time.monotonic()
h = asyncio.TimerHandle(when, callback, args, unittest.mock.Mock()) h = asyncio.TimerHandle(when, callback, args, mock.Mock())
self.assertIs(h._callback, callback) self.assertIs(h._callback, callback)
self.assertIs(h._args, args) self.assertIs(h._args, args)
self.assertFalse(h._cancelled) self.assertFalse(h._cancelled)
@ -1887,10 +1887,10 @@ class TimerTests(unittest.TestCase):
self.assertRaises(AssertionError, self.assertRaises(AssertionError,
asyncio.TimerHandle, None, callback, args, asyncio.TimerHandle, None, callback, args,
unittest.mock.Mock()) mock.Mock())
def test_timer_comparison(self): def test_timer_comparison(self):
loop = unittest.mock.Mock() loop = mock.Mock()
def callback(*args): def callback(*args):
return args return args
@ -1935,7 +1935,7 @@ class TimerTests(unittest.TestCase):
class AbstractEventLoopTests(unittest.TestCase): class AbstractEventLoopTests(unittest.TestCase):
def test_not_implemented(self): def test_not_implemented(self):
f = unittest.mock.Mock() f = mock.Mock()
loop = asyncio.AbstractEventLoop() loop = asyncio.AbstractEventLoop()
self.assertRaises( self.assertRaises(
NotImplementedError, loop.run_forever) NotImplementedError, loop.run_forever)
@ -1995,13 +1995,13 @@ class AbstractEventLoopTests(unittest.TestCase):
NotImplementedError, loop.remove_signal_handler, 1) NotImplementedError, loop.remove_signal_handler, 1)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.connect_read_pipe, f, NotImplementedError, loop.connect_read_pipe, f,
unittest.mock.sentinel.pipe) mock.sentinel.pipe)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.connect_write_pipe, f, NotImplementedError, loop.connect_write_pipe, f,
unittest.mock.sentinel.pipe) mock.sentinel.pipe)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.subprocess_shell, f, NotImplementedError, loop.subprocess_shell, f,
unittest.mock.sentinel) mock.sentinel)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.subprocess_exec, f) NotImplementedError, loop.subprocess_exec, f)
@ -2009,7 +2009,7 @@ class AbstractEventLoopTests(unittest.TestCase):
class ProtocolsAbsTests(unittest.TestCase): class ProtocolsAbsTests(unittest.TestCase):
def test_empty(self): def test_empty(self):
f = unittest.mock.Mock() f = mock.Mock()
p = asyncio.Protocol() p = asyncio.Protocol()
self.assertIsNone(p.connection_made(f)) self.assertIsNone(p.connection_made(f))
self.assertIsNone(p.connection_lost(f)) self.assertIsNone(p.connection_lost(f))
@ -2055,7 +2055,7 @@ class PolicyTests(unittest.TestCase):
def test_get_event_loop_calls_set_event_loop(self): def test_get_event_loop_calls_set_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy() policy = asyncio.DefaultEventLoopPolicy()
with unittest.mock.patch.object( with mock.patch.object(
policy, "set_event_loop", policy, "set_event_loop",
wraps=policy.set_event_loop) as m_set_event_loop: wraps=policy.set_event_loop) as m_set_event_loop:
@ -2073,7 +2073,7 @@ class PolicyTests(unittest.TestCase):
policy.set_event_loop(None) policy.set_event_loop(None)
self.assertRaises(AssertionError, policy.get_event_loop) self.assertRaises(AssertionError, policy.get_event_loop)
@unittest.mock.patch('asyncio.events.threading.current_thread') @mock.patch('asyncio.events.threading.current_thread')
def test_get_event_loop_thread(self, m_current_thread): def test_get_event_loop_thread(self, m_current_thread):
def f(): def f():

16
Lib/test/test_asyncio/test_futures.py
View file

@ -3,7 +3,7 @@
import concurrent.futures import concurrent.futures
import threading import threading
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio import test_utils from asyncio import test_utils
@ -174,20 +174,20 @@ class FutureTests(unittest.TestCase):
self.assertRaises(AssertionError, test) self.assertRaises(AssertionError, test)
fut.cancel() fut.cancel()
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_abandoned(self, m_log): def test_tb_logger_abandoned(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_result_unretrieved(self, m_log): def test_tb_logger_result_unretrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_result(42) fut.set_result(42)
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_result_retrieved(self, m_log): def test_tb_logger_result_retrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_result(42) fut.set_result(42)
@ -195,7 +195,7 @@ class FutureTests(unittest.TestCase):
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_exception_unretrieved(self, m_log): def test_tb_logger_exception_unretrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom')) fut.set_exception(RuntimeError('boom'))
@ -203,7 +203,7 @@ class FutureTests(unittest.TestCase):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertTrue(m_log.error.called) self.assertTrue(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_exception_retrieved(self, m_log): def test_tb_logger_exception_retrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom')) fut.set_exception(RuntimeError('boom'))
@ -211,7 +211,7 @@ class FutureTests(unittest.TestCase):
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_exception_result_retrieved(self, m_log): def test_tb_logger_exception_result_retrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom')) fut.set_exception(RuntimeError('boom'))
@ -236,7 +236,7 @@ class FutureTests(unittest.TestCase):
f2 = asyncio.wrap_future(f1) f2 = asyncio.wrap_future(f1)
self.assertIs(f1, f2) self.assertIs(f1, f2)
@unittest.mock.patch('asyncio.futures.events') @mock.patch('asyncio.futures.events')
def test_wrap_future_use_global_loop(self, m_events): def test_wrap_future_use_global_loop(self, m_events):
def run(arg): def run(arg):
return (arg, threading.get_ident()) return (arg, threading.get_ident())

20
Lib/test/test_asyncio/test_locks.py
View file

@ -1,7 +1,7 @@
"""Tests for lock.py""" """Tests for lock.py"""
import unittest import unittest
import unittest.mock from unittest import mock
import re import re
import asyncio import asyncio
@ -27,7 +27,7 @@ class LockTests(unittest.TestCase):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
lock = asyncio.Lock(loop=loop) lock = asyncio.Lock(loop=loop)
self.assertIs(lock._loop, loop) self.assertIs(lock._loop, loop)
@ -250,7 +250,7 @@ class EventTests(unittest.TestCase):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
ev = asyncio.Event(loop=loop) ev = asyncio.Event(loop=loop)
self.assertIs(ev._loop, loop) self.assertIs(ev._loop, loop)
@ -275,7 +275,7 @@ class EventTests(unittest.TestCase):
self.assertTrue(repr(ev).endswith('[set]>')) self.assertTrue(repr(ev).endswith('[set]>'))
self.assertTrue(RGX_REPR.match(repr(ev))) self.assertTrue(RGX_REPR.match(repr(ev)))
ev._waiters.append(unittest.mock.Mock()) ev._waiters.append(mock.Mock())
self.assertTrue('waiters:1' in repr(ev)) self.assertTrue('waiters:1' in repr(ev))
self.assertTrue(RGX_REPR.match(repr(ev))) self.assertTrue(RGX_REPR.match(repr(ev)))
@ -386,7 +386,7 @@ class ConditionTests(unittest.TestCase):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
cond = asyncio.Condition(loop=loop) cond = asyncio.Condition(loop=loop)
self.assertIs(cond._loop, loop) self.assertIs(cond._loop, loop)
@ -644,11 +644,11 @@ class ConditionTests(unittest.TestCase):
self.loop.run_until_complete(cond.acquire()) self.loop.run_until_complete(cond.acquire())
self.assertTrue('locked' in repr(cond)) self.assertTrue('locked' in repr(cond))
cond._waiters.append(unittest.mock.Mock()) cond._waiters.append(mock.Mock())
self.assertTrue('waiters:1' in repr(cond)) self.assertTrue('waiters:1' in repr(cond))
self.assertTrue(RGX_REPR.match(repr(cond))) self.assertTrue(RGX_REPR.match(repr(cond)))
cond._waiters.append(unittest.mock.Mock()) cond._waiters.append(mock.Mock())
self.assertTrue('waiters:2' in repr(cond)) self.assertTrue('waiters:2' in repr(cond))
self.assertTrue(RGX_REPR.match(repr(cond))) self.assertTrue(RGX_REPR.match(repr(cond)))
@ -688,7 +688,7 @@ class SemaphoreTests(unittest.TestCase):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
sem = asyncio.Semaphore(loop=loop) sem = asyncio.Semaphore(loop=loop)
self.assertIs(sem._loop, loop) self.assertIs(sem._loop, loop)
@ -717,11 +717,11 @@ class SemaphoreTests(unittest.TestCase):
self.assertTrue('waiters' not in repr(sem)) self.assertTrue('waiters' not in repr(sem))
self.assertTrue(RGX_REPR.match(repr(sem))) self.assertTrue(RGX_REPR.match(repr(sem)))
sem._waiters.append(unittest.mock.Mock()) sem._waiters.append(mock.Mock())
self.assertTrue('waiters:1' in repr(sem)) self.assertTrue('waiters:1' in repr(sem))
self.assertTrue(RGX_REPR.match(repr(sem))) self.assertTrue(RGX_REPR.match(repr(sem)))
sem._waiters.append(unittest.mock.Mock()) sem._waiters.append(mock.Mock())
self.assertTrue('waiters:2' in repr(sem)) self.assertTrue('waiters:2' in repr(sem))
self.assertTrue(RGX_REPR.match(repr(sem))) self.assertTrue(RGX_REPR.match(repr(sem)))

78
Lib/test/test_asyncio/test_proactor_events.py
View file

@ -2,7 +2,7 @@
import socket import socket
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio.proactor_events import BaseProactorEventLoop from asyncio.proactor_events import BaseProactorEventLoop
@ -16,10 +16,10 @@ class ProactorSocketTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.proactor = unittest.mock.Mock() self.proactor = mock.Mock()
self.loop._proactor = self.proactor self.loop._proactor = self.proactor
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
def test_ctor(self): def test_ctor(self):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
@ -56,7 +56,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
self.assertRaises(AssertionError, tr._loop_reading, res) self.assertRaises(AssertionError, tr._loop_reading, res)
tr.close = unittest.mock.Mock() tr.close = mock.Mock()
tr._read_fut = res tr._read_fut = res
tr._loop_reading(res) tr._loop_reading(res)
self.assertFalse(self.loop._proactor.recv.called) self.assertFalse(self.loop._proactor.recv.called)
@ -67,7 +67,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
err = self.loop._proactor.recv.side_effect = ConnectionAbortedError() err = self.loop._proactor.recv.side_effect = ConnectionAbortedError()
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
tr._fatal_error.assert_called_with( tr._fatal_error.assert_called_with(
err, err,
@ -78,7 +78,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._closing = True tr._closing = True
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
self.assertFalse(tr._fatal_error.called) self.assertFalse(tr._fatal_error.called)
@ -86,7 +86,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
self.loop._proactor.recv.side_effect = ConnectionAbortedError() self.loop._proactor.recv.side_effect = ConnectionAbortedError()
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._closing = False tr._closing = False
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
self.assertTrue(tr._fatal_error.called) self.assertTrue(tr._fatal_error.called)
@ -95,8 +95,8 @@ class ProactorSocketTransportTests(unittest.TestCase):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._closing = False tr._closing = False
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr._loop_reading() tr._loop_reading()
self.assertFalse(tr._fatal_error.called) self.assertFalse(tr._fatal_error.called)
tr._force_close.assert_called_with(err) tr._force_close.assert_called_with(err)
@ -105,7 +105,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
err = self.loop._proactor.recv.side_effect = (OSError()) err = self.loop._proactor.recv.side_effect = (OSError())
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
tr._fatal_error.assert_called_with( tr._fatal_error.assert_called_with(
err, err,
@ -113,7 +113,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
def test_write(self): def test_write(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._loop_writing = unittest.mock.Mock() tr._loop_writing = mock.Mock()
tr.write(b'data') tr.write(b'data')
self.assertEqual(tr._buffer, None) self.assertEqual(tr._buffer, None)
tr._loop_writing.assert_called_with(data=b'data') tr._loop_writing.assert_called_with(data=b'data')
@ -125,8 +125,8 @@ class ProactorSocketTransportTests(unittest.TestCase):
def test_write_more(self): def test_write_more(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._write_fut = unittest.mock.Mock() tr._write_fut = mock.Mock()
tr._loop_writing = unittest.mock.Mock() tr._loop_writing = mock.Mock()
tr.write(b'data') tr.write(b'data')
self.assertEqual(tr._buffer, b'data') self.assertEqual(tr._buffer, b'data')
self.assertFalse(tr._loop_writing.called) self.assertFalse(tr._loop_writing.called)
@ -139,11 +139,11 @@ class ProactorSocketTransportTests(unittest.TestCase):
self.loop._proactor.send.return_value.add_done_callback.\ self.loop._proactor.send.return_value.add_done_callback.\
assert_called_with(tr._loop_writing) assert_called_with(tr._loop_writing)
@unittest.mock.patch('asyncio.proactor_events.logger') @mock.patch('asyncio.proactor_events.logger')
def test_loop_writing_err(self, m_log): def test_loop_writing_err(self, m_log):
err = self.loop._proactor.send.side_effect = OSError() err = self.loop._proactor.send.side_effect = OSError()
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._buffer = [b'da', b'ta'] tr._buffer = [b'da', b'ta']
tr._loop_writing() tr._loop_writing()
tr._fatal_error.assert_called_with( tr._fatal_error.assert_called_with(
@ -182,7 +182,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
def test_abort(self): def test_abort(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr.abort() tr.abort()
tr._force_close.assert_called_with(None) tr._force_close.assert_called_with(None)
@ -201,7 +201,7 @@ class ProactorSocketTransportTests(unittest.TestCase):
def test_close_write_fut(self): def test_close_write_fut(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._write_fut = unittest.mock.Mock() tr._write_fut = mock.Mock()
tr.close() tr.close()
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertFalse(self.protocol.connection_lost.called) self.assertFalse(self.protocol.connection_lost.called)
@ -213,10 +213,10 @@ class ProactorSocketTransportTests(unittest.TestCase):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertFalse(self.protocol.connection_lost.called) self.assertFalse(self.protocol.connection_lost.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_fatal_error(self, m_logging): def test_fatal_error(self, m_logging):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr._fatal_error(None) tr._fatal_error(None)
self.assertTrue(tr._force_close.called) self.assertTrue(tr._force_close.called)
self.assertTrue(m_logging.error.called) self.assertTrue(m_logging.error.called)
@ -224,8 +224,8 @@ class ProactorSocketTransportTests(unittest.TestCase):
def test_force_close(self): def test_force_close(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._buffer = [b'data'] tr._buffer = [b'data']
read_fut = tr._read_fut = unittest.mock.Mock() read_fut = tr._read_fut = mock.Mock()
write_fut = tr._write_fut = unittest.mock.Mock() write_fut = tr._write_fut = mock.Mock()
tr._force_close(None) tr._force_close(None)
read_fut.cancel.assert_called_with() read_fut.cancel.assert_called_with()
@ -346,10 +346,10 @@ class ProactorSocketTransportTests(unittest.TestCase):
class BaseProactorEventLoopTests(unittest.TestCase): class BaseProactorEventLoopTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.proactor = unittest.mock.Mock() self.proactor = mock.Mock()
self.ssock, self.csock = unittest.mock.Mock(), unittest.mock.Mock() self.ssock, self.csock = mock.Mock(), mock.Mock()
class EventLoop(BaseProactorEventLoop): class EventLoop(BaseProactorEventLoop):
def _socketpair(s): def _socketpair(s):
@ -357,11 +357,11 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.loop = EventLoop(self.proactor) self.loop = EventLoop(self.proactor)
@unittest.mock.patch.object(BaseProactorEventLoop, 'call_soon') @mock.patch.object(BaseProactorEventLoop, 'call_soon')
@unittest.mock.patch.object(BaseProactorEventLoop, '_socketpair') @mock.patch.object(BaseProactorEventLoop, '_socketpair')
def test_ctor(self, socketpair, call_soon): def test_ctor(self, socketpair, call_soon):
ssock, csock = socketpair.return_value = ( ssock, csock = socketpair.return_value = (
unittest.mock.Mock(), unittest.mock.Mock()) mock.Mock(), mock.Mock())
loop = BaseProactorEventLoop(self.proactor) loop = BaseProactorEventLoop(self.proactor)
self.assertIs(loop._ssock, ssock) self.assertIs(loop._ssock, ssock)
self.assertIs(loop._csock, csock) self.assertIs(loop._csock, csock)
@ -377,7 +377,7 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.assertIsNone(self.loop._csock) self.assertIsNone(self.loop._csock)
def test_close(self): def test_close(self):
self.loop._close_self_pipe = unittest.mock.Mock() self.loop._close_self_pipe = mock.Mock()
self.loop.close() self.loop.close()
self.assertTrue(self.loop._close_self_pipe.called) self.assertTrue(self.loop._close_self_pipe.called)
self.assertTrue(self.proactor.close.called) self.assertTrue(self.proactor.close.called)
@ -418,7 +418,7 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.loop._loop_self_reading) self.loop._loop_self_reading)
def test_loop_self_reading_fut(self): def test_loop_self_reading_fut(self):
fut = unittest.mock.Mock() fut = mock.Mock()
self.loop._loop_self_reading(fut) self.loop._loop_self_reading(fut)
self.assertTrue(fut.result.called) self.assertTrue(fut.result.called)
self.proactor.recv.assert_called_with(self.ssock, 4096) self.proactor.recv.assert_called_with(self.ssock, 4096)
@ -426,7 +426,7 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.loop._loop_self_reading) self.loop._loop_self_reading)
def test_loop_self_reading_exception(self): def test_loop_self_reading_exception(self):
self.loop.close = unittest.mock.Mock() self.loop.close = mock.Mock()
self.proactor.recv.side_effect = OSError() self.proactor.recv.side_effect = OSError()
self.assertRaises(OSError, self.loop._loop_self_reading) self.assertRaises(OSError, self.loop._loop_self_reading)
self.assertTrue(self.loop.close.called) self.assertTrue(self.loop.close.called)
@ -438,10 +438,10 @@ class BaseProactorEventLoopTests(unittest.TestCase):
def test_process_events(self): def test_process_events(self):
self.loop._process_events([]) self.loop._process_events([])
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_create_server(self, m_log): def test_create_server(self, m_log):
pf = unittest.mock.Mock() pf = mock.Mock()
call_soon = self.loop.call_soon = unittest.mock.Mock() call_soon = self.loop.call_soon = mock.Mock()
self.loop._start_serving(pf, self.sock) self.loop._start_serving(pf, self.sock)
self.assertTrue(call_soon.called) self.assertTrue(call_soon.called)
@ -452,10 +452,10 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.proactor.accept.assert_called_with(self.sock) self.proactor.accept.assert_called_with(self.sock)
# conn # conn
fut = unittest.mock.Mock() fut = mock.Mock()
fut.result.return_value = (unittest.mock.Mock(), unittest.mock.Mock()) fut.result.return_value = (mock.Mock(), mock.Mock())
make_tr = self.loop._make_socket_transport = unittest.mock.Mock() make_tr = self.loop._make_socket_transport = mock.Mock()
loop(fut) loop(fut)
self.assertTrue(fut.result.called) self.assertTrue(fut.result.called)
self.assertTrue(make_tr.called) self.assertTrue(make_tr.called)
@ -467,8 +467,8 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.assertTrue(m_log.error.called) self.assertTrue(m_log.error.called)
def test_create_server_cancel(self): def test_create_server_cancel(self):
pf = unittest.mock.Mock() pf = mock.Mock()
call_soon = self.loop.call_soon = unittest.mock.Mock() call_soon = self.loop.call_soon = mock.Mock()
self.loop._start_serving(pf, self.sock) self.loop._start_serving(pf, self.sock)
loop = call_soon.call_args[0][0] loop = call_soon.call_args[0][0]
@ -480,7 +480,7 @@ class BaseProactorEventLoopTests(unittest.TestCase):
self.assertTrue(self.sock.close.called) self.assertTrue(self.sock.close.called)
def test_stop_serving(self): def test_stop_serving(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._stop_serving(sock) self.loop._stop_serving(sock)
self.assertTrue(sock.close.called) self.assertTrue(sock.close.called)
self.proactor._stop_serving.assert_called_with(sock) self.proactor._stop_serving.assert_called_with(sock)

4
Lib/test/test_asyncio/test_queues.py
View file

@ -1,7 +1,7 @@
"""Tests for queues.py""" """Tests for queues.py"""
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio import test_utils from asyncio import test_utils
@ -72,7 +72,7 @@ class QueueBasicTests(_QueueTestBase):
self.assertTrue('_queue=[1]' in fn(q)) self.assertTrue('_queue=[1]' in fn(q))
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
q = asyncio.Queue(loop=loop) q = asyncio.Queue(loop=loop)
self.assertIs(q._loop, loop) self.assertIs(q._loop, loop)

270
Lib/test/test_asyncio/test_selector_events.py
View file

@ -7,7 +7,7 @@ import pprint
import socket import socket
import sys import sys
import unittest import unittest
import unittest.mock from unittest import mock
try: try:
import ssl import ssl
except ImportError: except ImportError:
@ -23,14 +23,14 @@ from asyncio.selector_events import _SelectorSocketTransport
from asyncio.selector_events import _SelectorDatagramTransport from asyncio.selector_events import _SelectorDatagramTransport
MOCK_ANY = unittest.mock.ANY MOCK_ANY = mock.ANY
class TestBaseSelectorEventLoop(BaseSelectorEventLoop): class TestBaseSelectorEventLoop(BaseSelectorEventLoop):
def _make_self_pipe(self): def _make_self_pipe(self):
self._ssock = unittest.mock.Mock() self._ssock = mock.Mock()
self._csock = unittest.mock.Mock() self._csock = mock.Mock()
self._internal_fds += 1 self._internal_fds += 1
@ -41,34 +41,34 @@ def list_to_buffer(l=()):
class BaseSelectorEventLoopTests(unittest.TestCase): class BaseSelectorEventLoopTests(unittest.TestCase):
def setUp(self): def setUp(self):
selector = unittest.mock.Mock() selector = mock.Mock()
self.loop = TestBaseSelectorEventLoop(selector) self.loop = TestBaseSelectorEventLoop(selector)
def test_make_socket_transport(self): def test_make_socket_transport(self):
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
transport = self.loop._make_socket_transport(m, asyncio.Protocol()) transport = self.loop._make_socket_transport(m, asyncio.Protocol())
self.assertIsInstance(transport, _SelectorSocketTransport) self.assertIsInstance(transport, _SelectorSocketTransport)
@unittest.skipIf(ssl is None, 'No ssl module') @unittest.skipIf(ssl is None, 'No ssl module')
def test_make_ssl_transport(self): def test_make_ssl_transport(self):
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
waiter = asyncio.Future(loop=self.loop) waiter = asyncio.Future(loop=self.loop)
transport = self.loop._make_ssl_transport( transport = self.loop._make_ssl_transport(
m, asyncio.Protocol(), m, waiter) m, asyncio.Protocol(), m, waiter)
self.assertIsInstance(transport, _SelectorSslTransport) self.assertIsInstance(transport, _SelectorSslTransport)
@unittest.mock.patch('asyncio.selector_events.ssl', None) @mock.patch('asyncio.selector_events.ssl', None)
def test_make_ssl_transport_without_ssl_error(self): def test_make_ssl_transport_without_ssl_error(self):
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
self.loop._make_ssl_transport(m, m, m, m) self.loop._make_ssl_transport(m, m, m, m)
@ -77,10 +77,10 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
ssock.fileno.return_value = 7 ssock.fileno.return_value = 7
csock = self.loop._csock csock = self.loop._csock
csock.fileno.return_value = 1 csock.fileno.return_value = 1
remove_reader = self.loop.remove_reader = unittest.mock.Mock() remove_reader = self.loop.remove_reader = mock.Mock()
self.loop._selector.close() self.loop._selector.close()
self.loop._selector = selector = unittest.mock.Mock() self.loop._selector = selector = mock.Mock()
self.loop.close() self.loop.close()
self.assertIsNone(self.loop._selector) self.assertIsNone(self.loop._selector)
self.assertIsNone(self.loop._csock) self.assertIsNone(self.loop._csock)
@ -96,7 +96,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test_close_no_selector(self): def test_close_no_selector(self):
ssock = self.loop._ssock ssock = self.loop._ssock
csock = self.loop._csock csock = self.loop._csock
remove_reader = self.loop.remove_reader = unittest.mock.Mock() remove_reader = self.loop.remove_reader = mock.Mock()
self.loop._selector.close() self.loop._selector.close()
self.loop._selector = None self.loop._selector = None
@ -126,15 +126,15 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertRaises(OSError, self.loop._write_to_self) self.assertRaises(OSError, self.loop._write_to_self)
def test_sock_recv(self): def test_sock_recv(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_recv = unittest.mock.Mock() self.loop._sock_recv = mock.Mock()
f = self.loop.sock_recv(sock, 1024) f = self.loop.sock_recv(sock, 1024)
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
self.loop._sock_recv.assert_called_with(f, False, sock, 1024) self.loop._sock_recv.assert_called_with(f, False, sock, 1024)
def test__sock_recv_canceled_fut(self): def test__sock_recv_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -143,30 +143,30 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertFalse(sock.recv.called) self.assertFalse(sock.recv.called)
def test__sock_recv_unregister(self): def test__sock_recv_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop._sock_recv(f, True, sock, 1024) self.loop._sock_recv(f, True, sock, 1024)
self.assertEqual((10,), self.loop.remove_reader.call_args[0]) self.assertEqual((10,), self.loop.remove_reader.call_args[0])
def test__sock_recv_tryagain(self): def test__sock_recv_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.recv.side_effect = BlockingIOError sock.recv.side_effect = BlockingIOError
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop._sock_recv(f, False, sock, 1024) self.loop._sock_recv(f, False, sock, 1024)
self.assertEqual((10, self.loop._sock_recv, f, True, sock, 1024), self.assertEqual((10, self.loop._sock_recv, f, True, sock, 1024),
self.loop.add_reader.call_args[0]) self.loop.add_reader.call_args[0])
def test__sock_recv_exception(self): def test__sock_recv_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
err = sock.recv.side_effect = OSError() err = sock.recv.side_effect = OSError()
@ -174,8 +174,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertIs(err, f.exception()) self.assertIs(err, f.exception())
def test_sock_sendall(self): def test_sock_sendall(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_sendall = unittest.mock.Mock() self.loop._sock_sendall = mock.Mock()
f = self.loop.sock_sendall(sock, b'data') f = self.loop.sock_sendall(sock, b'data')
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -184,8 +184,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop._sock_sendall.call_args[0]) self.loop._sock_sendall.call_args[0])
def test_sock_sendall_nodata(self): def test_sock_sendall_nodata(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_sendall = unittest.mock.Mock() self.loop._sock_sendall = mock.Mock()
f = self.loop.sock_sendall(sock, b'') f = self.loop.sock_sendall(sock, b'')
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -194,7 +194,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertFalse(self.loop._sock_sendall.called) self.assertFalse(self.loop._sock_sendall.called)
def test__sock_sendall_canceled_fut(self): def test__sock_sendall_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -203,23 +203,23 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertFalse(sock.send.called) self.assertFalse(sock.send.called)
def test__sock_sendall_unregister(self): def test__sock_sendall_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_sendall(f, True, sock, b'data') self.loop._sock_sendall(f, True, sock, b'data')
self.assertEqual((10,), self.loop.remove_writer.call_args[0]) self.assertEqual((10,), self.loop.remove_writer.call_args[0])
def test__sock_sendall_tryagain(self): def test__sock_sendall_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.side_effect = BlockingIOError sock.send.side_effect = BlockingIOError
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertEqual( self.assertEqual(
(10, self.loop._sock_sendall, f, True, sock, b'data'), (10, self.loop._sock_sendall, f, True, sock, b'data'),
@ -227,11 +227,11 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test__sock_sendall_interrupted(self): def test__sock_sendall_interrupted(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.side_effect = InterruptedError sock.send.side_effect = InterruptedError
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertEqual( self.assertEqual(
(10, self.loop._sock_sendall, f, True, sock, b'data'), (10, self.loop._sock_sendall, f, True, sock, b'data'),
@ -239,7 +239,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test__sock_sendall_exception(self): def test__sock_sendall_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
err = sock.send.side_effect = OSError() err = sock.send.side_effect = OSError()
@ -247,7 +247,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertIs(f.exception(), err) self.assertIs(f.exception(), err)
def test__sock_sendall(self): def test__sock_sendall(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock.fileno.return_value = 10 sock.fileno.return_value = 10
@ -258,13 +258,13 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertIsNone(f.result()) self.assertIsNone(f.result())
def test__sock_sendall_partial(self): def test__sock_sendall_partial(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.return_value = 2 sock.send.return_value = 2
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertFalse(f.done()) self.assertFalse(f.done())
self.assertEqual( self.assertEqual(
@ -272,13 +272,13 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop.add_writer.call_args[0]) self.loop.add_writer.call_args[0])
def test__sock_sendall_none(self): def test__sock_sendall_none(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.return_value = 0 sock.send.return_value = 0
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertFalse(f.done()) self.assertFalse(f.done())
self.assertEqual( self.assertEqual(
@ -286,8 +286,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop.add_writer.call_args[0]) self.loop.add_writer.call_args[0])
def test_sock_connect(self): def test_sock_connect(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_connect = unittest.mock.Mock() self.loop._sock_connect = mock.Mock()
f = self.loop.sock_connect(sock, ('127.0.0.1', 8080)) f = self.loop.sock_connect(sock, ('127.0.0.1', 8080))
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -298,7 +298,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test__sock_connect(self): def test__sock_connect(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
self.loop._sock_connect(f, False, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, False, sock, ('127.0.0.1', 8080))
@ -307,7 +307,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertTrue(sock.connect.called) self.assertTrue(sock.connect.called)
def test__sock_connect_canceled_fut(self): def test__sock_connect_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -316,24 +316,24 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertFalse(sock.connect.called) self.assertFalse(sock.connect.called)
def test__sock_connect_unregister(self): def test__sock_connect_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080))
self.assertEqual((10,), self.loop.remove_writer.call_args[0]) self.assertEqual((10,), self.loop.remove_writer.call_args[0])
def test__sock_connect_tryagain(self): def test__sock_connect_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.getsockopt.return_value = errno.EAGAIN sock.getsockopt.return_value = errno.EAGAIN
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080))
self.assertEqual( self.assertEqual(
@ -343,17 +343,17 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test__sock_connect_exception(self): def test__sock_connect_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.getsockopt.return_value = errno.ENOTCONN sock.getsockopt.return_value = errno.ENOTCONN
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080))
self.assertIsInstance(f.exception(), OSError) self.assertIsInstance(f.exception(), OSError)
def test_sock_accept(self): def test_sock_accept(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_accept = unittest.mock.Mock() self.loop._sock_accept = mock.Mock()
f = self.loop.sock_accept(sock) f = self.loop.sock_accept(sock)
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -363,9 +363,9 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test__sock_accept(self): def test__sock_accept(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
conn = unittest.mock.Mock() conn = mock.Mock()
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.accept.return_value = conn, ('127.0.0.1', 1000) sock.accept.return_value = conn, ('127.0.0.1', 1000)
@ -375,7 +375,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertEqual((False,), conn.setblocking.call_args[0]) self.assertEqual((False,), conn.setblocking.call_args[0])
def test__sock_accept_canceled_fut(self): def test__sock_accept_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -384,23 +384,23 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertFalse(sock.accept.called) self.assertFalse(sock.accept.called)
def test__sock_accept_unregister(self): def test__sock_accept_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop._sock_accept(f, True, sock) self.loop._sock_accept(f, True, sock)
self.assertEqual((10,), self.loop.remove_reader.call_args[0]) self.assertEqual((10,), self.loop.remove_reader.call_args[0])
def test__sock_accept_tryagain(self): def test__sock_accept_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.accept.side_effect = BlockingIOError sock.accept.side_effect = BlockingIOError
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop._sock_accept(f, False, sock) self.loop._sock_accept(f, False, sock)
self.assertEqual( self.assertEqual(
(10, self.loop._sock_accept, f, True, sock), (10, self.loop._sock_accept, f, True, sock),
@ -408,7 +408,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
def test__sock_accept_exception(self): def test__sock_accept_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
err = sock.accept.side_effect = OSError() err = sock.accept.side_effect = OSError()
@ -428,8 +428,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertIsNone(w) self.assertIsNone(w)
def test_add_reader_existing(self): def test_add_reader_existing(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_WRITE, (reader, writer)) 1, 1, selectors.EVENT_WRITE, (reader, writer))
cb = lambda: True cb = lambda: True
@ -445,7 +445,7 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertEqual(writer, w) self.assertEqual(writer, w)
def test_add_reader_existing_writer(self): def test_add_reader_existing_writer(self):
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_WRITE, (None, writer)) 1, 1, selectors.EVENT_WRITE, (None, writer))
cb = lambda: True cb = lambda: True
@ -467,8 +467,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertTrue(self.loop._selector.unregister.called) self.assertTrue(self.loop._selector.unregister.called)
def test_remove_reader_read_write(self): def test_remove_reader_read_write(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE, 1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE,
(reader, writer)) (reader, writer))
@ -498,8 +498,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertEqual(cb, w._callback) self.assertEqual(cb, w._callback)
def test_add_writer_existing(self): def test_add_writer_existing(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_READ, (reader, writer)) 1, 1, selectors.EVENT_READ, (reader, writer))
cb = lambda: True cb = lambda: True
@ -522,8 +522,8 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.assertTrue(self.loop._selector.unregister.called) self.assertTrue(self.loop._selector.unregister.called)
def test_remove_writer_read_write(self): def test_remove_writer_read_write(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE, 1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE,
(reader, writer)) (reader, writer))
@ -541,10 +541,10 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop.remove_writer(1)) self.loop.remove_writer(1))
def test_process_events_read(self): def test_process_events_read(self):
reader = unittest.mock.Mock() reader = mock.Mock()
reader._cancelled = False reader._cancelled = False
self.loop._add_callback = unittest.mock.Mock() self.loop._add_callback = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey( [(selectors.SelectorKey(
1, 1, selectors.EVENT_READ, (reader, None)), 1, 1, selectors.EVENT_READ, (reader, None)),
@ -553,10 +553,10 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop._add_callback.assert_called_with(reader) self.loop._add_callback.assert_called_with(reader)
def test_process_events_read_cancelled(self): def test_process_events_read_cancelled(self):
reader = unittest.mock.Mock() reader = mock.Mock()
reader.cancelled = True reader.cancelled = True
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey( [(selectors.SelectorKey(
1, 1, selectors.EVENT_READ, (reader, None)), 1, 1, selectors.EVENT_READ, (reader, None)),
@ -564,10 +564,10 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop.remove_reader.assert_called_with(1) self.loop.remove_reader.assert_called_with(1)
def test_process_events_write(self): def test_process_events_write(self):
writer = unittest.mock.Mock() writer = mock.Mock()
writer._cancelled = False writer._cancelled = False
self.loop._add_callback = unittest.mock.Mock() self.loop._add_callback = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE, [(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE,
(None, writer)), (None, writer)),
@ -575,9 +575,9 @@ class BaseSelectorEventLoopTests(unittest.TestCase):
self.loop._add_callback.assert_called_with(writer) self.loop._add_callback.assert_called_with(writer)
def test_process_events_write_cancelled(self): def test_process_events_write_cancelled(self):
writer = unittest.mock.Mock() writer = mock.Mock()
writer.cancelled = True writer.cancelled = True
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE, [(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE,
@ -591,7 +591,7 @@ class SelectorTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.sock.fileno.return_value = 7 self.sock.fileno.return_value = 7
def test_ctor(self): def test_ctor(self):
@ -602,7 +602,7 @@ class SelectorTransportTests(unittest.TestCase):
def test_abort(self): def test_abort(self):
tr = _SelectorTransport(self.loop, self.sock, self.protocol, None) tr = _SelectorTransport(self.loop, self.sock, self.protocol, None)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr.abort() tr.abort()
tr._force_close.assert_called_with(None) tr._force_close.assert_called_with(None)
@ -632,8 +632,8 @@ class SelectorTransportTests(unittest.TestCase):
def test_force_close(self): def test_force_close(self):
tr = _SelectorTransport(self.loop, self.sock, self.protocol, None) tr = _SelectorTransport(self.loop, self.sock, self.protocol, None)
tr._buffer.extend(b'1') tr._buffer.extend(b'1')
self.loop.add_reader(7, unittest.mock.sentinel) self.loop.add_reader(7, mock.sentinel)
self.loop.add_writer(7, unittest.mock.sentinel) self.loop.add_writer(7, mock.sentinel)
tr._force_close(None) tr._force_close(None)
self.assertTrue(tr._closing) self.assertTrue(tr._closing)
@ -646,11 +646,11 @@ class SelectorTransportTests(unittest.TestCase):
self.assertFalse(self.loop.readers) self.assertFalse(self.loop.readers)
self.assertEqual(1, self.loop.remove_reader_count[7]) self.assertEqual(1, self.loop.remove_reader_count[7])
@unittest.mock.patch('asyncio.log.logger.error') @mock.patch('asyncio.log.logger.error')
def test_fatal_error(self, m_exc): def test_fatal_error(self, m_exc):
exc = OSError() exc = OSError()
tr = _SelectorTransport(self.loop, self.sock, self.protocol, None) tr = _SelectorTransport(self.loop, self.sock, self.protocol, None)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr._fatal_error(exc) tr._fatal_error(exc)
m_exc.assert_called_with( m_exc.assert_called_with(
@ -682,7 +682,7 @@ class SelectorSocketTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.sock_fd = self.sock.fileno.return_value = 7 self.sock_fd = self.sock.fileno.return_value = 7
def test_ctor(self): def test_ctor(self):
@ -724,7 +724,7 @@ class SelectorSocketTransportTests(unittest.TestCase):
def test_read_ready_eof(self): def test_read_ready_eof(self):
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport.close = unittest.mock.Mock() transport.close = mock.Mock()
self.sock.recv.return_value = b'' self.sock.recv.return_value = b''
transport._read_ready() transport._read_ready()
@ -735,7 +735,7 @@ class SelectorSocketTransportTests(unittest.TestCase):
def test_read_ready_eof_keep_open(self): def test_read_ready_eof_keep_open(self):
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport.close = unittest.mock.Mock() transport.close = mock.Mock()
self.sock.recv.return_value = b'' self.sock.recv.return_value = b''
self.protocol.eof_received.return_value = True self.protocol.eof_received.return_value = True
@ -744,45 +744,45 @@ class SelectorSocketTransportTests(unittest.TestCase):
self.protocol.eof_received.assert_called_with() self.protocol.eof_received.assert_called_with()
self.assertFalse(transport.close.called) self.assertFalse(transport.close.called)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_tryagain(self, m_exc): def test_read_ready_tryagain(self, m_exc):
self.sock.recv.side_effect = BlockingIOError self.sock.recv.side_effect = BlockingIOError
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_tryagain_interrupted(self, m_exc): def test_read_ready_tryagain_interrupted(self, m_exc):
self.sock.recv.side_effect = InterruptedError self.sock.recv.side_effect = InterruptedError
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_conn_reset(self, m_exc): def test_read_ready_conn_reset(self, m_exc):
err = self.sock.recv.side_effect = ConnectionResetError() err = self.sock.recv.side_effect = ConnectionResetError()
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._force_close = unittest.mock.Mock() transport._force_close = mock.Mock()
transport._read_ready() transport._read_ready()
transport._force_close.assert_called_with(err) transport._force_close.assert_called_with(err)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_err(self, m_exc): def test_read_ready_err(self, m_exc):
err = self.sock.recv.side_effect = OSError() err = self.sock.recv.side_effect = OSError()
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
@ -891,14 +891,14 @@ class SelectorSocketTransportTests(unittest.TestCase):
self.loop.assert_writer(7, transport._write_ready) self.loop.assert_writer(7, transport._write_ready)
self.assertEqual(list_to_buffer([b'data']), transport._buffer) self.assertEqual(list_to_buffer([b'data']), transport._buffer)
@unittest.mock.patch('asyncio.selector_events.logger') @mock.patch('asyncio.selector_events.logger')
def test_write_exception(self, m_log): def test_write_exception(self, m_log):
err = self.sock.send.side_effect = OSError() err = self.sock.send.side_effect = OSError()
data = b'data' data = b'data'
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.write(data) transport.write(data)
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
@ -1002,17 +1002,17 @@ class SelectorSocketTransportTests(unittest.TestCase):
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.extend(b'data') transport._buffer.extend(b'data')
transport._write_ready() transport._write_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
'Fatal write error on socket transport') 'Fatal write error on socket transport')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_write_ready_exception_and_close(self, m_log): def test_write_ready_exception_and_close(self, m_log):
self.sock.send.side_effect = OSError() self.sock.send.side_effect = OSError()
remove_writer = self.loop.remove_writer = unittest.mock.Mock() remove_writer = self.loop.remove_writer = mock.Mock()
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
@ -1053,11 +1053,11 @@ class SelectorSslTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.sock.fileno.return_value = 7 self.sock.fileno.return_value = 7
self.sslsock = unittest.mock.Mock() self.sslsock = mock.Mock()
self.sslsock.fileno.return_value = 1 self.sslsock.fileno.return_value = 1
self.sslcontext = unittest.mock.Mock() self.sslcontext = mock.Mock()
self.sslcontext.wrap_socket.return_value = self.sslsock self.sslcontext.wrap_socket.return_value = self.sslsock
def _make_one(self, create_waiter=None): def _make_one(self, create_waiter=None):
@ -1162,7 +1162,7 @@ class SelectorSslTransportTests(unittest.TestCase):
transport.write(b'data') transport.write(b'data')
self.assertEqual(transport._conn_lost, 2) self.assertEqual(transport._conn_lost, 2)
@unittest.mock.patch('asyncio.selector_events.logger') @mock.patch('asyncio.selector_events.logger')
def test_write_exception(self, m_log): def test_write_exception(self, m_log):
transport = self._make_one() transport = self._make_one()
transport._conn_lost = 1 transport._conn_lost = 1
@ -1182,11 +1182,11 @@ class SelectorSslTransportTests(unittest.TestCase):
self.assertEqual((b'data',), self.protocol.data_received.call_args[0]) self.assertEqual((b'data',), self.protocol.data_received.call_args[0])
def test_read_ready_write_wants_read(self): def test_read_ready_write_wants_read(self):
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.sslsock.recv.side_effect = BlockingIOError self.sslsock.recv.side_effect = BlockingIOError
transport = self._make_one() transport = self._make_one()
transport._write_wants_read = True transport._write_wants_read = True
transport._write_ready = unittest.mock.Mock() transport._write_ready = mock.Mock()
transport._buffer.extend(b'data') transport._buffer.extend(b'data')
transport._read_ready() transport._read_ready()
@ -1198,7 +1198,7 @@ class SelectorSslTransportTests(unittest.TestCase):
def test_read_ready_recv_eof(self): def test_read_ready_recv_eof(self):
self.sslsock.recv.return_value = b'' self.sslsock.recv.return_value = b''
transport = self._make_one() transport = self._make_one()
transport.close = unittest.mock.Mock() transport.close = mock.Mock()
transport._read_ready() transport._read_ready()
transport.close.assert_called_with() transport.close.assert_called_with()
self.protocol.eof_received.assert_called_with() self.protocol.eof_received.assert_called_with()
@ -1206,7 +1206,7 @@ class SelectorSslTransportTests(unittest.TestCase):
def test_read_ready_recv_conn_reset(self): def test_read_ready_recv_conn_reset(self):
err = self.sslsock.recv.side_effect = ConnectionResetError() err = self.sslsock.recv.side_effect = ConnectionResetError()
transport = self._make_one() transport = self._make_one()
transport._force_close = unittest.mock.Mock() transport._force_close = mock.Mock()
transport._read_ready() transport._read_ready()
transport._force_close.assert_called_with(err) transport._force_close.assert_called_with(err)
@ -1226,8 +1226,8 @@ class SelectorSslTransportTests(unittest.TestCase):
self.assertFalse(self.protocol.data_received.called) self.assertFalse(self.protocol.data_received.called)
def test_read_ready_recv_write(self): def test_read_ready_recv_write(self):
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.sslsock.recv.side_effect = ssl.SSLWantWriteError self.sslsock.recv.side_effect = ssl.SSLWantWriteError
transport = self._make_one() transport = self._make_one()
transport._read_ready() transport._read_ready()
@ -1241,7 +1241,7 @@ class SelectorSslTransportTests(unittest.TestCase):
def test_read_ready_recv_exc(self): def test_read_ready_recv_exc(self):
err = self.sslsock.recv.side_effect = OSError() err = self.sslsock.recv.side_effect = OSError()
transport = self._make_one() transport = self._make_one()
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
@ -1313,7 +1313,7 @@ class SelectorSslTransportTests(unittest.TestCase):
transport = self._make_one() transport = self._make_one()
transport._buffer = list_to_buffer([b'data']) transport._buffer = list_to_buffer([b'data'])
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.sslsock.send.side_effect = ssl.SSLWantReadError self.sslsock.send.side_effect = ssl.SSLWantReadError
transport._write_ready() transport._write_ready()
self.assertFalse(self.protocol.data_received.called) self.assertFalse(self.protocol.data_received.called)
@ -1325,7 +1325,7 @@ class SelectorSslTransportTests(unittest.TestCase):
transport = self._make_one() transport = self._make_one()
transport._buffer = list_to_buffer([b'data']) transport._buffer = list_to_buffer([b'data'])
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._write_ready() transport._write_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
@ -1333,11 +1333,11 @@ class SelectorSslTransportTests(unittest.TestCase):
self.assertEqual(list_to_buffer(), transport._buffer) self.assertEqual(list_to_buffer(), transport._buffer)
def test_write_ready_read_wants_write(self): def test_write_ready_read_wants_write(self):
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.sslsock.send.side_effect = BlockingIOError self.sslsock.send.side_effect = BlockingIOError
transport = self._make_one() transport = self._make_one()
transport._read_wants_write = True transport._read_wants_write = True
transport._read_ready = unittest.mock.Mock() transport._read_ready = mock.Mock()
transport._write_ready() transport._write_ready()
self.assertFalse(transport._read_wants_write) self.assertFalse(transport._read_wants_write)
@ -1374,9 +1374,9 @@ class SelectorSslTransportTests(unittest.TestCase):
class SelectorSslWithoutSslTransportTests(unittest.TestCase): class SelectorSslWithoutSslTransportTests(unittest.TestCase):
@unittest.mock.patch('asyncio.selector_events.ssl', None) @mock.patch('asyncio.selector_events.ssl', None)
def test_ssl_transport_requires_ssl_module(self): def test_ssl_transport_requires_ssl_module(self):
Mock = unittest.mock.Mock Mock = mock.Mock
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
transport = _SelectorSslTransport(Mock(), Mock(), Mock(), Mock()) transport = _SelectorSslTransport(Mock(), Mock(), Mock(), Mock())
@ -1386,7 +1386,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.DatagramProtocol) self.protocol = test_utils.make_test_protocol(asyncio.DatagramProtocol)
self.sock = unittest.mock.Mock(spec_set=socket.socket) self.sock = mock.Mock(spec_set=socket.socket)
self.sock.fileno.return_value = 7 self.sock.fileno.return_value = 7
def test_read_ready(self): def test_read_ready(self):
@ -1404,7 +1404,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
self.sock.recvfrom.side_effect = BlockingIOError self.sock.recvfrom.side_effect = BlockingIOError
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@ -1414,7 +1414,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
err = self.sock.recvfrom.side_effect = RuntimeError() err = self.sock.recvfrom.side_effect = RuntimeError()
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
@ -1426,7 +1426,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
err = self.sock.recvfrom.side_effect = OSError() err = self.sock.recvfrom.side_effect = OSError()
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@ -1518,14 +1518,14 @@ class SelectorDatagramTransportTests(unittest.TestCase):
self.assertEqual( self.assertEqual(
[(b'data', ('0.0.0.0', 12345))], list(transport._buffer)) [(b'data', ('0.0.0.0', 12345))], list(transport._buffer))
@unittest.mock.patch('asyncio.selector_events.logger') @mock.patch('asyncio.selector_events.logger')
def test_sendto_exception(self, m_log): def test_sendto_exception(self, m_log):
data = b'data' data = b'data'
err = self.sock.sendto.side_effect = RuntimeError() err = self.sock.sendto.side_effect = RuntimeError()
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.sendto(data, ()) transport.sendto(data, ())
self.assertTrue(transport._fatal_error.called) self.assertTrue(transport._fatal_error.called)
@ -1549,7 +1549,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.sendto(data, ()) transport.sendto(data, ())
self.assertEqual(transport._conn_lost, 0) self.assertEqual(transport._conn_lost, 0)
@ -1562,7 +1562,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol, ('0.0.0.0', 1)) self.loop, self.sock, self.protocol, ('0.0.0.0', 1))
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.sendto(data) transport.sendto(data)
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@ -1643,7 +1643,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.append((b'data', ())) transport._buffer.append((b'data', ()))
transport._sendto_ready() transport._sendto_ready()
@ -1656,7 +1656,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.append((b'data', ())) transport._buffer.append((b'data', ()))
transport._sendto_ready() transport._sendto_ready()
@ -1667,14 +1667,14 @@ class SelectorDatagramTransportTests(unittest.TestCase):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol, ('0.0.0.0', 1)) self.loop, self.sock, self.protocol, ('0.0.0.0', 1))
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.append((b'data', ())) transport._buffer.append((b'data', ()))
transport._sendto_ready() transport._sendto_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
self.assertTrue(self.protocol.error_received.called) self.assertTrue(self.protocol.error_received.called)
@unittest.mock.patch('asyncio.base_events.logger.error') @mock.patch('asyncio.base_events.logger.error')
def test_fatal_error_connected(self, m_exc): def test_fatal_error_connected(self, m_exc):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol, ('0.0.0.0', 1)) self.loop, self.sock, self.protocol, ('0.0.0.0', 1))

4
Lib/test/test_asyncio/test_streams.py
View file

@ -4,7 +4,7 @@ import functools
import gc import gc
import socket import socket
import unittest import unittest
import unittest.mock from unittest import mock
try: try:
import ssl import ssl
except ImportError: except ImportError:
@ -29,7 +29,7 @@ class StreamReaderTests(unittest.TestCase):
self.loop.close() self.loop.close()
gc.collect() gc.collect()
@unittest.mock.patch('asyncio.streams.events') @mock.patch('asyncio.streams.events')
def test_ctor_global_loop(self, m_events): def test_ctor_global_loop(self, m_events):
stream = asyncio.StreamReader() stream = asyncio.StreamReader()
self.assertIs(stream._loop, m_events.get_event_loop.return_value) self.assertIs(stream._loop, m_events.get_event_loop.return_value)

6
Lib/test/test_asyncio/test_transports.py
View file

@ -1,7 +1,7 @@
"""Tests for transports.py.""" """Tests for transports.py."""
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio import transports from asyncio import transports
@ -23,7 +23,7 @@ class TransportTests(unittest.TestCase):
def test_writelines(self): def test_writelines(self):
transport = asyncio.Transport() transport = asyncio.Transport()
transport.write = unittest.mock.Mock() transport.write = mock.Mock()
transport.writelines([b'line1', transport.writelines([b'line1',
bytearray(b'line2'), bytearray(b'line2'),
@ -70,7 +70,7 @@ class TransportTests(unittest.TestCase):
return 512 return 512
transport = MyTransport() transport = MyTransport()
transport._protocol = unittest.mock.Mock() transport._protocol = mock.Mock()
self.assertFalse(transport._protocol_paused) self.assertFalse(transport._protocol_paused)

190
Lib/test/test_asyncio/test_unix_events.py
View file

@ -13,7 +13,7 @@ import sys
import tempfile import tempfile
import threading import threading
import unittest import unittest
import unittest.mock from unittest import mock
if sys.platform == 'win32': if sys.platform == 'win32':
raise unittest.SkipTest('UNIX only') raise unittest.SkipTest('UNIX only')
@ -25,7 +25,7 @@ from asyncio import test_utils
from asyncio import unix_events from asyncio import unix_events
MOCK_ANY = unittest.mock.ANY MOCK_ANY = mock.ANY
@unittest.skipUnless(signal, 'Signals are not supported') @unittest.skipUnless(signal, 'Signals are not supported')
@ -48,15 +48,15 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.loop._handle_signal(signal.NSIG + 1, ()) self.loop._handle_signal(signal.NSIG + 1, ())
def test_handle_signal_cancelled_handler(self): def test_handle_signal_cancelled_handler(self):
h = asyncio.Handle(unittest.mock.Mock(), (), h = asyncio.Handle(mock.Mock(), (),
loop=unittest.mock.Mock()) loop=mock.Mock())
h.cancel() h.cancel()
self.loop._signal_handlers[signal.NSIG + 1] = h self.loop._signal_handlers[signal.NSIG + 1] = h
self.loop.remove_signal_handler = unittest.mock.Mock() self.loop.remove_signal_handler = mock.Mock()
self.loop._handle_signal(signal.NSIG + 1, ()) self.loop._handle_signal(signal.NSIG + 1, ())
self.loop.remove_signal_handler.assert_called_with(signal.NSIG + 1) self.loop.remove_signal_handler.assert_called_with(signal.NSIG + 1)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_add_signal_handler_setup_error(self, m_signal): def test_add_signal_handler_setup_error(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
m_signal.set_wakeup_fd.side_effect = ValueError m_signal.set_wakeup_fd.side_effect = ValueError
@ -66,7 +66,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.loop.add_signal_handler, self.loop.add_signal_handler,
signal.SIGINT, lambda: True) signal.SIGINT, lambda: True)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_add_signal_handler(self, m_signal): def test_add_signal_handler(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -76,7 +76,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.assertIsInstance(h, asyncio.Handle) self.assertIsInstance(h, asyncio.Handle)
self.assertEqual(h._callback, cb) self.assertEqual(h._callback, cb)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_add_signal_handler_install_error(self, m_signal): def test_add_signal_handler_install_error(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -94,8 +94,8 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.loop.add_signal_handler, self.loop.add_signal_handler,
signal.SIGINT, lambda: True) signal.SIGINT, lambda: True)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_add_signal_handler_install_error2(self, m_logging, m_signal): def test_add_signal_handler_install_error2(self, m_logging, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -111,8 +111,8 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.assertFalse(m_logging.info.called) self.assertFalse(m_logging.info.called)
self.assertEqual(1, m_signal.set_wakeup_fd.call_count) self.assertEqual(1, m_signal.set_wakeup_fd.call_count)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_add_signal_handler_install_error3(self, m_logging, m_signal): def test_add_signal_handler_install_error3(self, m_logging, m_signal):
class Err(OSError): class Err(OSError):
errno = errno.EINVAL errno = errno.EINVAL
@ -126,7 +126,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.assertFalse(m_logging.info.called) self.assertFalse(m_logging.info.called)
self.assertEqual(2, m_signal.set_wakeup_fd.call_count) self.assertEqual(2, m_signal.set_wakeup_fd.call_count)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler(self, m_signal): def test_remove_signal_handler(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -139,7 +139,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.assertEqual( self.assertEqual(
(signal.SIGHUP, m_signal.SIG_DFL), m_signal.signal.call_args[0]) (signal.SIGHUP, m_signal.SIG_DFL), m_signal.signal.call_args[0])
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler_2(self, m_signal): def test_remove_signal_handler_2(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
m_signal.SIGINT = signal.SIGINT m_signal.SIGINT = signal.SIGINT
@ -156,8 +156,8 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
(signal.SIGINT, m_signal.default_int_handler), (signal.SIGINT, m_signal.default_int_handler),
m_signal.signal.call_args[0]) m_signal.signal.call_args[0])
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_remove_signal_handler_cleanup_error(self, m_logging, m_signal): def test_remove_signal_handler_cleanup_error(self, m_logging, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
self.loop.add_signal_handler(signal.SIGHUP, lambda: True) self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
@ -167,7 +167,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.loop.remove_signal_handler(signal.SIGHUP) self.loop.remove_signal_handler(signal.SIGHUP)
self.assertTrue(m_logging.info) self.assertTrue(m_logging.info)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler_error(self, m_signal): def test_remove_signal_handler_error(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
self.loop.add_signal_handler(signal.SIGHUP, lambda: True) self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
@ -177,7 +177,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.assertRaises( self.assertRaises(
OSError, self.loop.remove_signal_handler, signal.SIGHUP) OSError, self.loop.remove_signal_handler, signal.SIGHUP)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler_error2(self, m_signal): def test_remove_signal_handler_error2(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
self.loop.add_signal_handler(signal.SIGHUP, lambda: True) self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
@ -189,7 +189,7 @@ class SelectorEventLoopSignalTests(unittest.TestCase):
self.assertRaises( self.assertRaises(
RuntimeError, self.loop.remove_signal_handler, signal.SIGHUP) RuntimeError, self.loop.remove_signal_handler, signal.SIGHUP)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_close(self, m_signal): def test_close(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -291,16 +291,16 @@ class UnixReadPipeTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.pipe = unittest.mock.Mock(spec_set=io.RawIOBase) self.pipe = mock.Mock(spec_set=io.RawIOBase)
self.pipe.fileno.return_value = 5 self.pipe.fileno.return_value = 5
fcntl_patcher = unittest.mock.patch('fcntl.fcntl') fcntl_patcher = mock.patch('fcntl.fcntl')
fcntl_patcher.start() fcntl_patcher.start()
self.addCleanup(fcntl_patcher.stop) self.addCleanup(fcntl_patcher.stop)
fstat_patcher = unittest.mock.patch('os.fstat') fstat_patcher = mock.patch('os.fstat')
m_fstat = fstat_patcher.start() m_fstat = fstat_patcher.start()
st = unittest.mock.Mock() st = mock.Mock()
st.st_mode = stat.S_IFIFO st.st_mode = stat.S_IFIFO
m_fstat.return_value = st m_fstat.return_value = st
self.addCleanup(fstat_patcher.stop) self.addCleanup(fstat_patcher.stop)
@ -319,7 +319,7 @@ class UnixReadPipeTransportTests(unittest.TestCase):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertIsNone(fut.result()) self.assertIsNone(fut.result())
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready(self, m_read): def test__read_ready(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -329,7 +329,7 @@ class UnixReadPipeTransportTests(unittest.TestCase):
m_read.assert_called_with(5, tr.max_size) m_read.assert_called_with(5, tr.max_size)
self.protocol.data_received.assert_called_with(b'data') self.protocol.data_received.assert_called_with(b'data')
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready_eof(self, m_read): def test__read_ready_eof(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -342,7 +342,7 @@ class UnixReadPipeTransportTests(unittest.TestCase):
self.protocol.eof_received.assert_called_with() self.protocol.eof_received.assert_called_with()
self.protocol.connection_lost.assert_called_with(None) self.protocol.connection_lost.assert_called_with(None)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready_blocked(self, m_read): def test__read_ready_blocked(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -353,14 +353,14 @@ class UnixReadPipeTransportTests(unittest.TestCase):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertFalse(self.protocol.data_received.called) self.assertFalse(self.protocol.data_received.called)
@unittest.mock.patch('asyncio.log.logger.error') @mock.patch('asyncio.log.logger.error')
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready_error(self, m_read, m_logexc): def test__read_ready_error(self, m_read, m_logexc):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
err = OSError() err = OSError()
m_read.side_effect = err m_read.side_effect = err
tr._close = unittest.mock.Mock() tr._close = mock.Mock()
tr._read_ready() tr._read_ready()
m_read.assert_called_with(5, tr.max_size) m_read.assert_called_with(5, tr.max_size)
@ -371,17 +371,17 @@ class UnixReadPipeTransportTests(unittest.TestCase):
'\nprotocol:.*\ntransport:.*'), '\nprotocol:.*\ntransport:.*'),
exc_info=(OSError, MOCK_ANY, MOCK_ANY)) exc_info=(OSError, MOCK_ANY, MOCK_ANY))
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_pause_reading(self, m_read): def test_pause_reading(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader(5, m) self.loop.add_reader(5, m)
tr.pause_reading() tr.pause_reading()
self.assertFalse(self.loop.readers) self.assertFalse(self.loop.readers)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_resume_reading(self, m_read): def test_resume_reading(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -389,26 +389,26 @@ class UnixReadPipeTransportTests(unittest.TestCase):
tr.resume_reading() tr.resume_reading()
self.loop.assert_reader(5, tr._read_ready) self.loop.assert_reader(5, tr._read_ready)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_close(self, m_read): def test_close(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr._close = unittest.mock.Mock() tr._close = mock.Mock()
tr.close() tr.close()
tr._close.assert_called_with(None) tr._close.assert_called_with(None)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_close_already_closing(self, m_read): def test_close_already_closing(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr._closing = True tr._closing = True
tr._close = unittest.mock.Mock() tr._close = mock.Mock()
tr.close() tr.close()
self.assertFalse(tr._close.called) self.assertFalse(tr._close.called)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__close(self, m_read): def test__close(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -459,16 +459,16 @@ class UnixWritePipeTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.BaseProtocol) self.protocol = test_utils.make_test_protocol(asyncio.BaseProtocol)
self.pipe = unittest.mock.Mock(spec_set=io.RawIOBase) self.pipe = mock.Mock(spec_set=io.RawIOBase)
self.pipe.fileno.return_value = 5 self.pipe.fileno.return_value = 5
fcntl_patcher = unittest.mock.patch('fcntl.fcntl') fcntl_patcher = mock.patch('fcntl.fcntl')
fcntl_patcher.start() fcntl_patcher.start()
self.addCleanup(fcntl_patcher.stop) self.addCleanup(fcntl_patcher.stop)
fstat_patcher = unittest.mock.patch('os.fstat') fstat_patcher = mock.patch('os.fstat')
m_fstat = fstat_patcher.start() m_fstat = fstat_patcher.start()
st = unittest.mock.Mock() st = mock.Mock()
st.st_mode = stat.S_IFSOCK st.st_mode = stat.S_IFSOCK
m_fstat.return_value = st m_fstat.return_value = st
self.addCleanup(fstat_patcher.stop) self.addCleanup(fstat_patcher.stop)
@ -493,7 +493,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
self.assertTrue(tr.can_write_eof()) self.assertTrue(tr.can_write_eof())
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write(self, m_write): def test_write(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -504,7 +504,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
self.assertEqual([], tr._buffer) self.assertEqual([], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_no_data(self, m_write): def test_write_no_data(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -514,7 +514,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
self.assertEqual([], tr._buffer) self.assertEqual([], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_partial(self, m_write): def test_write_partial(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -525,7 +525,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'ta'], tr._buffer) self.assertEqual([b'ta'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_buffer(self, m_write): def test_write_buffer(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -537,7 +537,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'previous', b'data'], tr._buffer) self.assertEqual([b'previous', b'data'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_again(self, m_write): def test_write_again(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -548,15 +548,15 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'data'], tr._buffer) self.assertEqual([b'data'], tr._buffer)
@unittest.mock.patch('asyncio.unix_events.logger') @mock.patch('asyncio.unix_events.logger')
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_err(self, m_write, m_log): def test_write_err(self, m_write, m_log):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
err = OSError() err = OSError()
m_write.side_effect = err m_write.side_effect = err
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr.write(b'data') tr.write(b'data')
m_write.assert_called_with(5, b'data') m_write.assert_called_with(5, b'data')
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
@ -576,7 +576,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
m_log.warning.assert_called_with( m_log.warning.assert_called_with(
'pipe closed by peer or os.write(pipe, data) raised exception.') 'pipe closed by peer or os.write(pipe, data) raised exception.')
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_close(self, m_write): def test_write_close(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -597,7 +597,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.protocol.connection_lost.assert_called_with(None) self.protocol.connection_lost.assert_called_with(None)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready(self, m_write): def test__write_ready(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -609,7 +609,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
self.assertEqual([], tr._buffer) self.assertEqual([], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_partial(self, m_write): def test__write_ready_partial(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -622,7 +622,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'a'], tr._buffer) self.assertEqual([b'a'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_again(self, m_write): def test__write_ready_again(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -635,7 +635,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'data'], tr._buffer) self.assertEqual([b'data'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_empty(self, m_write): def test__write_ready_empty(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -648,8 +648,8 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'data'], tr._buffer) self.assertEqual([b'data'], tr._buffer)
@unittest.mock.patch('asyncio.log.logger.error') @mock.patch('asyncio.log.logger.error')
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_err(self, m_write, m_logexc): def test__write_ready_err(self, m_write, m_logexc):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -672,7 +672,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.protocol.connection_lost.assert_called_with(err) self.protocol.connection_lost.assert_called_with(err)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_closing(self, m_write): def test__write_ready_closing(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -689,7 +689,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
self.protocol.connection_lost.assert_called_with(None) self.protocol.connection_lost.assert_called_with(None)
self.pipe.close.assert_called_with() self.pipe.close.assert_called_with()
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_abort(self, m_write): def test_abort(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -742,7 +742,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr.write_eof = unittest.mock.Mock() tr.write_eof = mock.Mock()
tr.close() tr.close()
tr.write_eof.assert_called_with() tr.write_eof.assert_called_with()
@ -750,7 +750,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr.write_eof = unittest.mock.Mock() tr.write_eof = mock.Mock()
tr._closing = True tr._closing = True
tr.close() tr.close()
self.assertFalse(tr.write_eof.called) self.assertFalse(tr.write_eof.called)
@ -777,7 +777,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
class AbstractChildWatcherTests(unittest.TestCase): class AbstractChildWatcherTests(unittest.TestCase):
def test_not_implemented(self): def test_not_implemented(self):
f = unittest.mock.Mock() f = mock.Mock()
watcher = asyncio.AbstractChildWatcher() watcher = asyncio.AbstractChildWatcher()
self.assertRaises( self.assertRaises(
NotImplementedError, watcher.add_child_handler, f, f) NotImplementedError, watcher.add_child_handler, f, f)
@ -796,7 +796,7 @@ class AbstractChildWatcherTests(unittest.TestCase):
class BaseChildWatcherTests(unittest.TestCase): class BaseChildWatcherTests(unittest.TestCase):
def test_not_implemented(self): def test_not_implemented(self):
f = unittest.mock.Mock() f = mock.Mock()
watcher = unix_events.BaseChildWatcher() watcher = unix_events.BaseChildWatcher()
self.assertRaises( self.assertRaises(
NotImplementedError, watcher._do_waitpid, f) NotImplementedError, watcher._do_waitpid, f)
@ -813,14 +813,14 @@ WaitPidMocks = collections.namedtuple("WaitPidMocks",
class ChildWatcherTestsMixin: class ChildWatcherTestsMixin:
ignore_warnings = unittest.mock.patch.object(log.logger, "warning") ignore_warnings = mock.patch.object(log.logger, "warning")
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.running = False self.running = False
self.zombies = {} self.zombies = {}
with unittest.mock.patch.object( with mock.patch.object(
self.loop, "add_signal_handler") as self.m_add_signal_handler: self.loop, "add_signal_handler") as self.m_add_signal_handler:
self.watcher = self.create_watcher() self.watcher = self.create_watcher()
self.watcher.attach_loop(self.loop) self.watcher.attach_loop(self.loop)
@ -864,8 +864,8 @@ class ChildWatcherTestsMixin:
def waitpid_mocks(func): def waitpid_mocks(func):
def wrapped_func(self): def wrapped_func(self):
def patch(target, wrapper): def patch(target, wrapper):
return unittest.mock.patch(target, wraps=wrapper, return mock.patch(target, wraps=wrapper,
new_callable=unittest.mock.Mock) new_callable=mock.Mock)
with patch('os.WTERMSIG', self.WTERMSIG) as m_WTERMSIG, \ with patch('os.WTERMSIG', self.WTERMSIG) as m_WTERMSIG, \
patch('os.WEXITSTATUS', self.WEXITSTATUS) as m_WEXITSTATUS, \ patch('os.WEXITSTATUS', self.WEXITSTATUS) as m_WEXITSTATUS, \
@ -881,7 +881,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld(self, m): def test_sigchld(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -941,8 +941,8 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_two_children(self, m): def test_sigchld_two_children(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
# register child 1 # register child 1
with self.watcher: with self.watcher:
@ -1045,8 +1045,8 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_two_children_terminating_together(self, m): def test_sigchld_two_children_terminating_together(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
# register child 1 # register child 1
with self.watcher: with self.watcher:
@ -1115,7 +1115,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_race_condition(self, m): def test_sigchld_race_condition(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
# child terminates before being registered # child terminates before being registered
@ -1136,8 +1136,8 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_replace_handler(self, m): def test_sigchld_replace_handler(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1189,7 +1189,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_remove_handler(self, m): def test_sigchld_remove_handler(self, m):
callback = unittest.mock.Mock() callback = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1221,7 +1221,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_unknown_status(self, m): def test_sigchld_unknown_status(self, m):
callback = unittest.mock.Mock() callback = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1258,9 +1258,9 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_remove_child_handler(self, m): def test_remove_child_handler(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
callback3 = unittest.mock.Mock() callback3 = mock.Mock()
# register children # register children
with self.watcher: with self.watcher:
@ -1291,7 +1291,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_unhandled_exception(self, m): def test_sigchld_unhandled_exception(self, m):
callback = unittest.mock.Mock() callback = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1301,7 +1301,7 @@ class ChildWatcherTestsMixin:
# raise an exception # raise an exception
m.waitpid.side_effect = ValueError m.waitpid.side_effect = ValueError
with unittest.mock.patch.object(log.logger, with mock.patch.object(log.logger,
'error') as m_error: 'error') as m_error:
self.assertEqual(self.watcher._sig_chld(), None) self.assertEqual(self.watcher._sig_chld(), None)
@ -1310,7 +1310,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_child_reaped_elsewhere(self, m): def test_sigchld_child_reaped_elsewhere(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1346,8 +1346,8 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_sigchld_unknown_pid_during_registration(self, m): def test_sigchld_unknown_pid_during_registration(self, m):
# register two children # register two children
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
with self.ignore_warnings, self.watcher: with self.ignore_warnings, self.watcher:
self.running = True self.running = True
@ -1367,7 +1367,7 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_set_loop(self, m): def test_set_loop(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1377,10 +1377,10 @@ class ChildWatcherTestsMixin:
old_loop = self.loop old_loop = self.loop
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
with unittest.mock.patch.object( with mock.patch.object(
old_loop, old_loop,
"remove_signal_handler") as m_old_remove_signal_handler, \ "remove_signal_handler") as m_old_remove_signal_handler, \
unittest.mock.patch.object( mock.patch.object(
self.loop, self.loop,
"add_signal_handler") as m_new_add_signal_handler: "add_signal_handler") as m_new_add_signal_handler:
@ -1401,9 +1401,9 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_set_loop_race_condition(self, m): def test_set_loop_race_condition(self, m):
# register 3 children # register 3 children
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
callback3 = unittest.mock.Mock() callback3 = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1415,7 +1415,7 @@ class ChildWatcherTestsMixin:
old_loop = self.loop old_loop = self.loop
self.loop = None self.loop = None
with unittest.mock.patch.object( with mock.patch.object(
old_loop, "remove_signal_handler") as m_remove_signal_handler: old_loop, "remove_signal_handler") as m_remove_signal_handler:
self.watcher.attach_loop(None) self.watcher.attach_loop(None)
@ -1435,7 +1435,7 @@ class ChildWatcherTestsMixin:
# attach a new loop # attach a new loop
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
with unittest.mock.patch.object( with mock.patch.object(
self.loop, "add_signal_handler") as m_add_signal_handler: self.loop, "add_signal_handler") as m_add_signal_handler:
self.watcher.attach_loop(self.loop) self.watcher.attach_loop(self.loop)
@ -1461,8 +1461,8 @@ class ChildWatcherTestsMixin:
@waitpid_mocks @waitpid_mocks
def test_close(self, m): def test_close(self, m):
# register two children # register two children
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1479,7 +1479,7 @@ class ChildWatcherTestsMixin:
if isinstance(self.watcher, asyncio.FastChildWatcher): if isinstance(self.watcher, asyncio.FastChildWatcher):
self.assertEqual(len(self.watcher._zombies), 1) self.assertEqual(len(self.watcher._zombies), 1)
with unittest.mock.patch.object( with mock.patch.object(
self.loop, self.loop,
"remove_signal_handler") as m_remove_signal_handler: "remove_signal_handler") as m_remove_signal_handler:

4
Lib/test/test_asyncio/test_windows_utils.py
View file

@ -3,7 +3,7 @@
import sys import sys
import test.support import test.support
import unittest import unittest
import unittest.mock from unittest import mock
if sys.platform != 'win32': if sys.platform != 'win32':
raise unittest.SkipTest('Windows only') raise unittest.SkipTest('Windows only')
@ -25,7 +25,7 @@ class WinsocketpairTests(unittest.TestCase):
csock.close() csock.close()
ssock.close() ssock.close()
@unittest.mock.patch('asyncio.windows_utils.socket') @mock.patch('asyncio.windows_utils.socket')
def test_winsocketpair_exc(self, m_socket): def test_winsocketpair_exc(self, m_socket):
m_socket.socket.return_value.getsockname.return_value = ('', 12345) m_socket.socket.return_value.getsockname.return_value = ('', 12345)
m_socket.socket.return_value.accept.return_value = object(), object() m_socket.socket.return_value.accept.return_value = object(), object()