def test_connect_timeout(self):
url = '/'
host, port = TARPIT_HOST, 80
timeout = Timeout(connect=SHORT_TIMEOUT)
# Pool-global timeout
pool = HTTPConnectionPool(host, port, timeout=timeout)
self.addCleanup(pool.close)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url)
# Retries
retries = Retry(connect=0)
self.assertRaises(MaxRetryError, pool.request, 'GET', url, retries=retries)
# Request-specific connection timeouts
big_timeout = Timeout(read=LONG_TIMEOUT, connect=LONG_TIMEOUT)
pool = HTTPConnectionPool(host, port, timeout=big_timeout, retries=False)
self.addCleanup(pool.close)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError,
pool._make_request,
conn, 'GET', url,
timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, 'GET', url, timeout=timeout)
def test_connect_timeout(self):
url = '/sleep?seconds=0.005'
timeout = Timeout(connect=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url)
# Retries
retries = Retry(connect=0)
self.assertRaises(MaxRetryError, pool.request, 'GET', url,
retries=retries)
# Request-specific connection timeouts
big_timeout = Timeout(read=0.2, connect=0.2)
pool = HTTPConnectionPool(TARPIT_HOST, self.port,
timeout=big_timeout, retries=False)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET',
url, timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, 'GET', url,
timeout=timeout)
def test_timeout(self):
url = '/sleep?seconds=0.005'
timeout = 0.001
# Pool-global timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
conn = pool._get_conn()
with self.assertRaises(SocketTimeout):
pool._make_request(conn, 'GET', url)
pool._put_conn(conn)
with self.assertRaises(TimeoutError):
pool.request('GET', url)
# Request-specific timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=0.5)
conn = pool._get_conn()
with self.assertRaises(SocketTimeout):
pool._make_request(conn, 'GET', url, timeout=timeout)
pool._put_conn(conn)
with self.assertRaises(TimeoutError):
pool.request('GET', url, timeout=timeout)
def test_connect_timeout(self):
def noop_handler(listener):
return
self._start_server(noop_handler)
url = '/'
host, port = self.host, self.port
timeout = Timeout(connect=SHORT_TIMEOUT)
# Pool-global timeout
pool = HTTPConnectionPool(host, port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url)
# Retries
retries = Retry(connect=0)
self.assertRaises(MaxRetryError, pool.request, 'GET', url, retries=retries)
# Request-specific connection timeouts
big_timeout = Timeout(read=LONG_TIMEOUT, connect=LONG_TIMEOUT)
pool = HTTPConnectionPool(host, port, timeout=big_timeout, retries=False)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url, timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, 'GET', url, timeout=timeout)
def test_timeout(self):
# Requests should time out when expected
block_event = Event()
ready_event = self.start_basic_handler(block_send=block_event, num=6)
# Pool-global timeout
timeout = Timeout(read=SHORT_TIMEOUT)
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout, retries=False)
self.addCleanup(pool.close)
wait_for_socket(ready_event)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, 'GET', '/')
pool._put_conn(conn)
block_event.set() # Release request
wait_for_socket(ready_event)
block_event.clear()
self.assertRaises(ReadTimeoutError, pool.request, 'GET', '/')
block_event.set() # Release request
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host, self.port, timeout=LONG_TIMEOUT, retries=False)
self.addCleanup(pool.close)
conn = pool._get_conn()
wait_for_socket(ready_event)
now = time.time()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, 'GET', '/', timeout=timeout)
delta = time.time() - now
block_event.set() # Release request
message = "timeout was pool-level LONG_TIMEOUT rather than request-level SHORT_TIMEOUT"
self.assertTrue(delta < LONG_TIMEOUT, message)
pool._put_conn(conn)
wait_for_socket(ready_event)
now = time.time()
self.assertRaises(ReadTimeoutError, pool.request, 'GET', '/', timeout=timeout)
delta = time.time() - now
message = "timeout was pool-level LONG_TIMEOUT rather than request-level SHORT_TIMEOUT"
self.assertTrue(delta < LONG_TIMEOUT, message)
block_event.set() # Release request
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
wait_for_socket(ready_event)
self.assertRaises(ReadTimeoutError, pool.request, 'GET', '/', timeout=SHORT_TIMEOUT)
block_event.set() # Release request
wait_for_socket(ready_event)
conn = pool._new_conn()
# FIXME: This assert flakes sometimes. Not sure why.
self.assertRaises(ReadTimeoutError,
pool._make_request,
conn, 'GET', '/',
timeout=SHORT_TIMEOUT)
block_event.set() # Release request
def test_conn_closed(self):
pool = HTTPConnectionPool(self.host, self.port, timeout=0.001)
conn = pool._get_conn()
pool._put_conn(conn)
try:
url = '/sleep?seconds=0.005'
pool.urlopen('GET', url)
self.fail("The request should fail with a timeout error.")
except ReadTimeoutError:
if conn.sock:
self.assertRaises(socket.error, conn.sock.recv, 1024)
finally:
pool._put_conn(conn)
def test_conn_closed(self):
block_event = Event()
self.start_basic_handler(block_send=block_event, num=1)
pool = HTTPConnectionPool(self.host, self.port, timeout=SHORT_TIMEOUT, retries=False)
conn = pool._get_conn()
pool._put_conn(conn)
try:
pool.urlopen('GET', '/')
self.fail("The request should fail with a timeout error.")
except ReadTimeoutError:
if conn.sock:
self.assertRaises(socket.error, conn.sock.recv, 1024)
finally:
pool._put_conn(conn)
block_event.set()
def test_connect_timeout(self):
url = "/sleep"
timeout = util.Timeout(connect=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, "GET", url)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, "GET", url)
# Request-specific connection timeouts
big_timeout = util.Timeout(read=0.5, connect=0.5)
pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=big_timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, "GET", url, timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, "GET", url, timeout=timeout)
def test_timeout(self):
url = "/sleep?seconds=0.005"
timeout = 0.001
# Pool-global timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(SocketTimeout, pool._make_request, conn, "GET", url)
pool._put_conn(conn)
self.assertRaises(TimeoutError, pool.request, "GET", url)
# Request-specific timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=0.5)
conn = pool._get_conn()
self.assertRaises(SocketTimeout, pool._make_request, conn, "GET", url, timeout=timeout)
pool._put_conn(conn)
self.assertRaises(TimeoutError, pool.request, "GET", url, timeout=timeout)
def test_conn_closed(self):
block_event = Event()
self.start_basic_handler(block_send=block_event, num=1)
pool = HTTPConnectionPool(self.host,
self.port,
timeout=SHORT_TIMEOUT,
retries=False)
self.addCleanup(pool.close)
conn = pool._get_conn()
pool._put_conn(conn)
try:
pool.urlopen('GET', '/')
self.fail("The request should fail with a timeout error.")
except ReadTimeoutError:
if conn.sock:
self.assertRaises(socket.error, conn.sock.recv, 1024)
finally:
pool._put_conn(conn)
block_event.set()
def test_connect_timeout(self):
url = '/sleep'
timeout = util.Timeout(connect=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, 'GET', url)
# Request-specific connection timeouts
big_timeout = util.Timeout(read=0.5, connect=0.5)
pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=big_timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET',
url, timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError, pool.request, 'GET', url,
timeout=timeout)
def test_timeout(self):
url = "/sleep?seconds=0.005"
timeout = util.Timeout(read=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url)
pool._put_conn(conn)
self.assertRaises(ReadTimeoutError, pool.request, "GET", url)
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host, self.port, timeout=0.5)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url, timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ReadTimeoutError, pool.request, "GET", url, timeout=timeout)
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
self.assertRaises(ReadTimeoutError, pool.request, "GET", url, timeout=0.001)
conn = pool._new_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url, timeout=0.001)
pool._put_conn(conn)
# Timeout int/float passed directly to _make_request should not raise a
# request timeout if it's a high value
pool.request("GET", url, timeout=5)
def test_keepalive_close(self):
# NOTE: This used to run against apache.org but it made the test suite
# really slow and fail half the time. Setting it to skip until we can
# make this run better locally.
pool = HTTPConnectionPool(self.host,
self.port,
block=True,
maxsize=1,
timeout=2)
r = pool.request('GET',
'/keepalive?close=1',
retries=0,
headers={
"Connection": "close",
})
self.assertEqual(pool.num_connections, 1)
# The dummyserver will have responded with Connection:close,
# and httplib will properly cleanup the socket.
# We grab the HTTPConnection object straight from the Queue,
# because _get_conn() is where the check & reset occurs
# pylint: disable-msg=W0212
conn = pool.pool.get()
self.assertEqual(conn.sock, None)
pool._put_conn(conn)
# Now with keep-alive
r = pool.request('GET',
'/keepalive?close=0',
retries=0,
headers={
"Connection": "keep-alive",
})
# The dummyserver responded with Connection:keep-alive, the connection
# persists.
conn = pool.pool.get()
self.assertNotEqual(conn.sock, None)
pool._put_conn(conn)
# Another request asking the server to close the connection. This one
# should get cleaned up for the next request.
r = pool.request('GET',
'/keepalive?close=1',
retries=0,
headers={
"Connection": "close",
})
self.assertEqual(r.status, 200)
conn = pool.pool.get()
self.assertEqual(conn.sock, None)
pool._put_conn(conn)
# Next request
r = pool.request('GET', '/keepalive?close=0')
def test_connect_timeout(self):
url = '/'
host, port = TARPIT_HOST, 80
timeout = Timeout(connect=SHORT_TIMEOUT)
# Pool-global timeout
pool = HTTPConnectionPool(host, port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET',
url)
# Retries
retries = Retry(connect=0)
self.assertRaises(MaxRetryError,
pool.request,
'GET',
url,
retries=retries)
# Request-specific connection timeouts
big_timeout = Timeout(read=LONG_TIMEOUT, connect=LONG_TIMEOUT)
pool = HTTPConnectionPool(host,
port,
timeout=big_timeout,
retries=False)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError,
pool._make_request,
conn,
'GET',
url,
timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError,
pool.request,
'GET',
url,
timeout=timeout)
def test_keepalive_close(self):
pool = HTTPConnectionPool(self.host,
self.port,
block=True,
maxsize=1,
timeout=2)
self.addCleanup(pool.close)
r = pool.request('GET',
'/keepalive?close=1',
retries=0,
headers={
"Connection": "close",
})
self.assertEqual(pool.num_connections, 1)
# The dummyserver will have responded with Connection:close,
# and httplib will properly cleanup the socket.
# We grab the HTTPConnection object straight from the Queue,
# because _get_conn() is where the check & reset occurs
# pylint: disable-msg=W0212
conn = pool.pool.get()
self.assertEqual(conn._sock, None)
pool._put_conn(conn)
# Now with keep-alive
r = pool.request('GET',
'/keepalive?close=0',
retries=0,
headers={
"Connection": "keep-alive",
})
# The dummyserver responded with Connection:keep-alive, the connection
# persists.
conn = pool.pool.get()
self.assertNotEqual(conn._sock, None)
pool._put_conn(conn)
# Another request asking the server to close the connection. This one
# should get cleaned up for the next request.
r = pool.request('GET',
'/keepalive?close=1',
retries=0,
headers={
"Connection": "close",
})
self.assertEqual(r.status, 200)
conn = pool.pool.get()
self.assertEqual(conn._sock, None)
pool._put_conn(conn)
# Next request
r = pool.request('GET', '/keepalive?close=0')
def test_connect_timeout(self):
url = '/sleep?seconds=0.005'
timeout = Timeout(connect=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET',
url)
# Retries
retries = Retry(connect=0)
self.assertRaises(MaxRetryError,
pool.request,
'GET',
url,
retries=retries)
# Request-specific connection timeouts
big_timeout = Timeout(read=0.2, connect=0.2)
pool = HTTPConnectionPool(TARPIT_HOST,
self.port,
timeout=big_timeout,
retries=False)
conn = pool._get_conn()
self.assertRaises(ConnectTimeoutError,
pool._make_request,
conn,
'GET',
url,
timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ConnectTimeoutError,
pool.request,
'GET',
url,
timeout=timeout)
def test_connect_timeout(self):
url = '/'
host, port = TARPIT_HOST, 80
timeout = Timeout(connect=SHORT_TIMEOUT)
# Pool-global timeout
pool = HTTPConnectionPool(host, port, timeout=timeout)
conn = pool._get_conn()
with self.assertRaises(ConnectTimeoutError) as cmgr:
pool._make_request(conn, 'GET', url)
self.assertEqual(cmgr.exception.args[1].split()[-1],
'timeout=%s)' % timeout.connect_timeout)
# Retries
retries = Retry(connect=0)
self.assertRaises(MaxRetryError,
pool.request,
'GET',
url,
retries=retries)
# Request-specific connection timeouts
big_timeout = Timeout(read=LONG_TIMEOUT, connect=LONG_TIMEOUT)
pool = HTTPConnectionPool(host,
port,
timeout=big_timeout,
retries=False)
conn = pool._get_conn()
with self.assertRaises(ConnectTimeoutError) as cmgr:
pool._make_request(conn, 'GET', url, timeout=timeout)
self.assertEqual(cmgr.exception.args[1].split()[-1],
'timeout=%s)' % timeout.connect_timeout)
pool._put_conn(conn)
with self.assertRaises(ConnectTimeoutError) as cmgr:
pool.request('GET', url, timeout=timeout)
self.assertEqual(cmgr.exception.args[1].split()[-1],
'timeout=%s)' % timeout.connect_timeout)
def test_timeout(self):
url = '/sleep?seconds=0.005'
timeout = util.Timeout(read=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, 'GET',
url)
pool._put_conn(conn)
self.assertRaises(ReadTimeoutError, pool.request, 'GET', url)
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host, self.port, timeout=0.5)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError,
pool._make_request,
conn,
'GET',
url,
timeout=timeout)
pool._put_conn(conn)
self.assertRaises(ReadTimeoutError,
pool.request,
'GET',
url,
timeout=timeout)
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
self.assertRaises(ReadTimeoutError,
pool.request,
'GET',
url,
timeout=0.001)
conn = pool._new_conn()
self.assertRaises(ReadTimeoutError,
pool._make_request,
conn,
'GET',
url,
timeout=0.001)
pool._put_conn(conn)
# Timeout int/float passed directly to _make_request should not raise a
# request timeout if it's a high value
pool.request('GET', url, timeout=5)
def test_keepalive_close(self):
# NOTE: This used to run against apache.org but it made the test suite
# really slow and fail half the time. Setting it to skip until we can
# make this run better locally.
pool = HTTPConnectionPool(self.host, self.port,
block=True, maxsize=1, timeout=2)
r = pool.request('GET', '/keepalive?close=1', retries=0,
headers={
"Connection": "close",
})
self.assertEqual(pool.num_connections, 1)
# The dummyserver will have responded with Connection:close,
# and httplib will properly cleanup the socket.
# We grab the HTTPConnection object straight from the Queue,
# because _get_conn() is where the check & reset occurs
# pylint: disable-msg=W0212
conn = pool.pool.get()
self.assertEqual(conn.sock, None)
pool._put_conn(conn)
# Now with keep-alive
r = pool.request('GET', '/keepalive?close=0', retries=0,
headers={
"Connection": "keep-alive",
})
# The dummyserver responded with Connection:keep-alive, the connection
# persists.
conn = pool.pool.get()
self.assertNotEqual(conn.sock, None)
pool._put_conn(conn)
# Another request asking the server to close the connection. This one
# should get cleaned up for the next request.
r = pool.request('GET', '/keepalive?close=1', retries=0,
headers={
"Connection": "close",
})
self.assertEqual(r.status, 200)
conn = pool.pool.get()
self.assertEqual(conn.sock, None)
pool._put_conn(conn)
# Next request
r = pool.request('GET', '/keepalive?close=0')
def test_keepalive_close(self):
pool = HTTPConnectionPool(self.host, self.port,
block=True, maxsize=1, timeout=2)
self.addCleanup(pool.close)
r = pool.request('GET', '/keepalive?close=1', retries=0,
headers={
"Connection": "close",
})
self.assertEqual(pool.num_connections, 1)
# The dummyserver will have responded with Connection:close,
# and httplib will properly cleanup the socket.
# We grab the HTTPConnection object straight from the Queue,
# because _get_conn() is where the check & reset occurs
# pylint: disable-msg=W0212
conn = pool.pool.get()
self.assertIsNone(conn.sock)
pool._put_conn(conn)
# Now with keep-alive
r = pool.request('GET', '/keepalive?close=0', retries=0,
headers={
"Connection": "keep-alive",
})
# The dummyserver responded with Connection:keep-alive, the connection
# persists.
conn = pool.pool.get()
self.assertIsNotNone(conn.sock)
pool._put_conn(conn)
# Another request asking the server to close the connection. This one
# should get cleaned up for the next request.
r = pool.request('GET', '/keepalive?close=1', retries=0,
headers={
"Connection": "close",
})
self.assertEqual(r.status, 200)
conn = pool.pool.get()
self.assertIsNone(conn.sock)
pool._put_conn(conn)
# Next request
r = pool.request('GET', '/keepalive?close=0')
def test_timeout(self):
""" Requests should time out when expected """
url = '/sleep?seconds=0.003'
timeout = Timeout(read=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout, retries=False)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request,
conn, 'GET', url)
pool._put_conn(conn)
time.sleep(0.02) # Wait for server to start receiving again. :(
self.assertRaises(ReadTimeoutError, pool.request, 'GET', url)
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host, self.port, timeout=0.1, retries=False)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request,
conn, 'GET', url, timeout=timeout)
pool._put_conn(conn)
time.sleep(0.02) # Wait for server to start receiving again. :(
self.assertRaises(ReadTimeoutError, pool.request,
'GET', url, timeout=timeout)
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
self.assertRaises(ReadTimeoutError, pool.request,
'GET', url, timeout=0.001)
conn = pool._new_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn,
'GET', url, timeout=0.001)
pool._put_conn(conn)
# Timeout int/float passed directly to _make_request should not raise a
# request timeout if it's a high value
pool.request('GET', url, timeout=1)
def test_timeout(self):
""" Requests should time out when expected """
url = '/sleep?seconds=0.003'
timeout = Timeout(read=0.001)
# Pool-global timeout
pool = HTTPConnectionPool(self.host, self.port, timeout=timeout, retries=False)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request,
conn, 'GET', url)
pool._put_conn(conn)
time.sleep(0.02) # Wait for server to start receiving again. :(
self.assertRaises(ReadTimeoutError, pool.request, 'GET', url)
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host, self.port, timeout=0.1, retries=False)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request,
conn, 'GET', url, timeout=timeout)
pool._put_conn(conn)
time.sleep(0.02) # Wait for server to start receiving again. :(
self.assertRaises(ReadTimeoutError, pool.request,
'GET', url, timeout=timeout)
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
self.assertRaises(ReadTimeoutError, pool.request,
'GET', url, timeout=0.001)
conn = pool._new_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn,
'GET', url, timeout=0.001)
pool._put_conn(conn)
# Timeout int/float passed directly to _make_request should not raise a
# request timeout if it's a high value
pool.request('GET', url, timeout=1)
def test_timeout(self):
# Requests should time out when expected
block_event = Event()
ready_event = self.start_basic_handler(block_send=block_event, num=6)
# Pool-global timeout
timeout = Timeout(read=SHORT_TIMEOUT)
pool = HTTPConnectionPool(self.host,
self.port,
timeout=timeout,
retries=False)
self.addCleanup(pool.close)
wait_for_socket(ready_event)
conn = pool._get_conn()
self.assertRaises(ReadTimeoutError, pool._make_request, conn, 'GET',
'/')
pool._put_conn(conn)
block_event.set() # Release request
wait_for_socket(ready_event)
block_event.clear()
self.assertRaises(ReadTimeoutError, pool.request, 'GET', '/')
block_event.set() # Release request
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host,
self.port,
timeout=LONG_TIMEOUT,
retries=False)
self.addCleanup(pool.close)
conn = pool._get_conn()
wait_for_socket(ready_event)
now = time.time()
self.assertRaises(ReadTimeoutError,
pool._make_request,
conn,
'GET',
'/',
timeout=timeout)
delta = time.time() - now
block_event.set() # Release request
message = "timeout was pool-level LONG_TIMEOUT rather than request-level SHORT_TIMEOUT"
self.assertTrue(delta < LONG_TIMEOUT, message)
pool._put_conn(conn)
wait_for_socket(ready_event)
now = time.time()
self.assertRaises(ReadTimeoutError,
pool.request,
'GET',
'/',
timeout=timeout)
delta = time.time() - now
message = "timeout was pool-level LONG_TIMEOUT rather than request-level SHORT_TIMEOUT"
self.assertTrue(delta < LONG_TIMEOUT, message)
block_event.set() # Release request
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
wait_for_socket(ready_event)
self.assertRaises(ReadTimeoutError,
pool.request,
'GET',
'/',
timeout=SHORT_TIMEOUT)
block_event.set() # Release request
wait_for_socket(ready_event)
conn = pool._new_conn()
# FIXME: This assert flakes sometimes. Not sure why.
self.assertRaises(ReadTimeoutError,
pool._make_request,
conn,
'GET',
'/',
timeout=SHORT_TIMEOUT)
block_event.set() # Release request
def test_timeout(self):
# Requests should time out when expected
block_event = Event()
ready_event = self.start_basic_handler(block_send=block_event, num=6)
# Pool-global timeout
timeout = Timeout(read=SHORT_TIMEOUT)
pool = HTTPConnectionPool(self.host,
self.port,
timeout=timeout,
retries=False)
wait_for_socket(ready_event)
conn = pool._get_conn()
with self.assertRaises(ReadTimeoutError) as cmgr:
pool._make_request(conn, 'GET', '/')
self.assertEqual(cmgr.exception.args[0].split()[-1],
'timeout=%s)' % timeout.read_timeout)
pool._put_conn(conn)
block_event.set() # Release request
wait_for_socket(ready_event)
block_event.clear()
with self.assertRaises(ReadTimeoutError) as cmgr:
pool.request('GET', '/')
self.assertEqual(cmgr.exception.args[0].split()[-1],
'timeout=%s)' % timeout.read_timeout)
block_event.set() # Release request
# Request-specific timeouts should raise errors
pool = HTTPConnectionPool(self.host,
self.port,
timeout=LONG_TIMEOUT,
retries=False)
conn = pool._get_conn()
wait_for_socket(ready_event)
now = time.time()
with self.assertRaises(ReadTimeoutError) as cmgr:
pool._make_request(conn, 'GET', '/', timeout=timeout)
self.assertEqual(cmgr.exception.args[0].split()[-1],
'timeout=%s)' % timeout.read_timeout)
delta = time.time() - now
block_event.set() # Release request
self.assertTrue(
delta < LONG_TIMEOUT,
"timeout was pool-level LONG_TIMEOUT rather than request-level SHORT_TIMEOUT"
)
pool._put_conn(conn)
wait_for_socket(ready_event)
now = time.time()
with self.assertRaises(ReadTimeoutError) as cmgr:
pool.request('GET', '/', timeout=timeout)
self.assertEqual(cmgr.exception.args[0].split()[-1],
'timeout=%s)' % timeout.read_timeout)
delta = time.time() - now
self.assertTrue(
delta < LONG_TIMEOUT,
"timeout was pool-level LONG_TIMEOUT rather than request-level SHORT_TIMEOUT"
)
block_event.set() # Release request
# Timeout int/float passed directly to request and _make_request should
# raise a request timeout
wait_for_socket(ready_event)
with self.assertRaises(ReadTimeoutError) as cmgr:
pool.request('GET', '/', timeout=SHORT_TIMEOUT)
self.assertEqual(cmgr.exception.args[0].split()[-1],
'timeout=%s)' % SHORT_TIMEOUT)
block_event.set() # Release request
wait_for_socket(ready_event)
conn = pool._new_conn()
# FIXME: This assert flakes sometimes. Not sure why.
with self.assertRaises(ReadTimeoutError) as cmgr:
pool._make_request(conn, 'GET', '/', timeout=SHORT_TIMEOUT)
block_event.set() # Release request
self.assertEqual(cmgr.exception.args[0].split()[-1],
'timeout=%s)' % SHORT_TIMEOUT)