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()
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url))

        # Retries
        retries = Retry(connect=0)
        yield From(self.aioAssertRaises(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()
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET',
                          url, timeout=timeout))

        pool._put_conn(conn)
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool.request, 'GET', url,
                          timeout=timeout))
    def test_total_timeout(self):
        url = '/sleep?seconds=0.005'

        timeout = Timeout(connect=3, read=5, total=0.001)
        pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url))

        # This will get the socket to raise an EAGAIN on the read
        timeout = Timeout(connect=3, read=0)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request, conn, 'GET', url))

        # The connect should succeed and this should hit the read timeout
        timeout = Timeout(connect=3, read=5, total=0.002)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request, conn, 'GET', url))
 def test_timeout_reset(self):
     """ If the read timeout isn't set, socket timeout should reset """
     url = '/sleep?seconds=0.005'
     timeout = Timeout(connect=0.001)
     pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
     conn = pool._get_conn()
     try:
         yield From(pool._make_request(conn, 'GET', url))
     except ReadTimeoutError:
         self.fail("This request shouldn't trigger a read timeout.")
    def test_total_timeout(self):
        url = "/sleep?seconds=0.005"

        timeout = Timeout(connect=3, read=5, total=0.001)
        pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, "GET", url))

        # This will get the socket to raise an EAGAIN on the read
        timeout = Timeout(connect=3, read=0)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url))

        # The connect should succeed and this should hit the read timeout
        timeout = Timeout(connect=3, read=5, total=0.002)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url))
 def test_timeout_reset(self):
     """ If the read timeout isn't set, socket timeout should reset """
     url = "/sleep?seconds=0.005"
     timeout = Timeout(connect=0.001)
     pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
     conn = pool._get_conn()
     try:
         yield From(pool._make_request(conn, "GET", url))
     except ReadTimeoutError:
         self.fail("This request shouldn't trigger a read timeout.")
    def test_timeout(self):
        """ Requests should time out when expected """
        url = '/sleep?seconds=0.002'
        timeout = Timeout(read=0.001)

        # Pool-global timeout
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout, retries=False)

        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request,
                          conn, 'GET', url))
        pool._put_conn(conn)

        time.sleep(0.02) # Wait for server to start receiving again. :(

        yield From(self.aioAssertRaises(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()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request,
                          conn, 'GET', url, timeout=timeout))
        pool._put_conn(conn)

        time.sleep(0.02) # Wait for server to start receiving again. :(

        yield From(self.aioAssertRaises(ReadTimeoutError, pool.request,
                          'GET', url, timeout=timeout))

        # Timeout int/float passed directly to request and _make_request should
        # raise a request timeout
        yield From(self.aioAssertRaises(ReadTimeoutError, pool.request,
                          'GET', url, timeout=0.001))
        conn = pool._new_conn()
        yield From(self.aioAssertRaises(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
        yield From(pool.request('GET', url, timeout=1))
 def test_nagle(self):
     """ Test that connections have TCP_NODELAY turned on """
     # This test needs to be here in order to be run. socket.create_connection actually tries to
     # connect to the host provided so we need a dummyserver to be running.
     pool = HTTPConnectionPool(self.host, self.port)
     conn = pool._get_conn()
     yield From(pool._make_request(conn, 'GET', '/'))
     tcp_nodelay_setting = conn.sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
     assert tcp_nodelay_setting > 0, ("Expected TCP_NODELAY to be set on the "
                                      "socket (with value greater than 0) "
                                      "but instead was %s" %
                                      tcp_nodelay_setting)
    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()
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, "GET", url))

        # Retries
        retries = Retry(connect=0)
        yield From(self.aioAssertRaises(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()
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, "GET", url, timeout=timeout))

        pool._put_conn(conn)
        yield From(self.aioAssertRaises(ConnectTimeoutError, pool.request, "GET", url, timeout=timeout))
    def test_tunnel(self):
        # note the actual httplib.py has no tests for this functionality
        timeout = Timeout(total=None)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()
        try:
            conn.set_tunnel(self.host, self.port)
        except AttributeError: # python 2.6
            conn._set_tunnel(self.host, self.port)

        conn._tunnel = mock.Mock(return_value=None)
        yield From(pool._make_request(conn, 'GET', '/'))
        conn._tunnel.assert_called_once_with()

        # test that it's not called when tunnel is not set
        timeout = Timeout(total=None)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()

        conn._tunnel = mock.Mock(return_value=None)
        yield From(pool._make_request(conn, 'GET', '/'))
        self.assertEqual(conn._tunnel.called, False)
 def test_conn_closed(self):
     pool = HTTPConnectionPool(self.host, self.port, timeout=0.001, retries=False)
     conn = pool._get_conn()
     pool._put_conn(conn)
     try:
         url = '/sleep?seconds=0.005'
         yield From(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_tunnel(self):
        # note the actual httplib.py has no tests for this functionality
        timeout = Timeout(total=None)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()
        try:
            conn.set_tunnel(self.host, self.port)
        except AttributeError:  # python 2.6
            conn._set_tunnel(self.host, self.port)

        conn._tunnel = mock.Mock(return_value=None)
        yield From(pool._make_request(conn, "GET", "/"))
        conn._tunnel.assert_called_once_with()

        # test that it's not called when tunnel is not set
        timeout = Timeout(total=None)
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout)
        conn = pool._get_conn()

        conn._tunnel = mock.Mock(return_value=None)
        yield From(pool._make_request(conn, "GET", "/"))
        self.assertEqual(conn._tunnel.called, False)
 def test_nagle(self):
     """ Test that connections have TCP_NODELAY turned on """
     # This test needs to be here in order to be run. socket.create_connection actually tries to
     # connect to the host provided so we need a dummyserver to be running.
     pool = HTTPConnectionPool(self.host, self.port)
     conn = pool._get_conn()
     yield From(pool._make_request(conn, "GET", "/"))
     tcp_nodelay_setting = conn.sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
     assert tcp_nodelay_setting > 0, (
         "Expected TCP_NODELAY to be set on the "
         "socket (with value greater than 0) "
         "but instead was %s" % tcp_nodelay_setting
     )
 def test_conn_closed(self):
     pool = HTTPConnectionPool(self.host, self.port, timeout=0.001, retries=False)
     conn = pool._get_conn()
     pool._put_conn(conn)
     try:
         url = "/sleep?seconds=0.005"
         yield From(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_timeout(self):
        """ Requests should time out when expected """
        url = "/sleep?seconds=0.002"
        timeout = Timeout(read=0.001)

        # Pool-global timeout
        pool = HTTPConnectionPool(self.host, self.port, timeout=timeout, retries=False)

        conn = pool._get_conn()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url))
        pool._put_conn(conn)

        time.sleep(0.02)  # Wait for server to start receiving again. :(

        yield From(self.aioAssertRaises(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()
        yield From(self.aioAssertRaises(ReadTimeoutError, pool._make_request, conn, "GET", url, timeout=timeout))
        pool._put_conn(conn)

        time.sleep(0.02)  # Wait for server to start receiving again. :(

        yield From(self.aioAssertRaises(ReadTimeoutError, pool.request, "GET", url, timeout=timeout))

        # Timeout int/float passed directly to request and _make_request should
        # raise a request timeout
        yield From(self.aioAssertRaises(ReadTimeoutError, pool.request, "GET", url, timeout=0.001))
        conn = pool._new_conn()
        yield From(self.aioAssertRaises(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
        yield From(pool.request("GET", url, timeout=1))
 def test_none_total_applies_connect(self):
     url = '/sleep?seconds=0.005'
     timeout = Timeout(total=None, connect=0.001)
     pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
     conn = pool._get_conn()
     yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, 'GET', url))
 def test_none_total_applies_connect(self):
     url = "/sleep?seconds=0.005"
     timeout = Timeout(total=None, connect=0.001)
     pool = HTTPConnectionPool(TARPIT_HOST, self.port, timeout=timeout)
     conn = pool._get_conn()
     yield From(self.aioAssertRaises(ConnectTimeoutError, pool._make_request, conn, "GET", url))