def prepare_request(url,
method,
params=None,
headers=None,
body=None,
json=None,
**kwargs):
"""Prepare request."""
req_data = {
'url':
url,
'method':
method,
'timeouts':
Timeouts(
sock_read=kwargs.get('sock_read', 30),
sock_connect=kwargs.get('sock_connect', 30),
)
}
if params:
req_data['params'] = dict(params)
if headers:
req_data['headers'] = dict(headers)
if body:
req_data['data'] = body
if json:
req_data['json'] = json
return req_data
async def test_timeouts_overriden(app, aiohttp_server, mocker):
"""Test timeouts overriden."""
server = await aiohttp_server(app)
url = 'http://localhost:%d/slow_request' % server.port
# request takes 1s so this timeout should not be applied
# instead the one provided by request call
connector = TCPConnector(timeouts=Timeouts(sock_read=2))
async with aiosonic.HTTPClient(connector) as client:
response = await client.get(url)
assert response.status_code == 200
with pytest.raises(ReadTimeout):
await client.get(url, timeouts=Timeouts(sock_read=0.3))
await server.close()
async def test_get_http2(http2_serv):
"""Test simple get to node http2 server."""
url = http2_serv
connector = TCPConnector(timeouts=Timeouts(sock_connect=3, sock_read=4))
res = await aiosonic.get(url, connector=connector, verify=False)
assert res.status_code == 200
assert 'Hello World' == await res.text()
async def test_read_timeout(app, aiohttp_server, mocker):
"""Test read timeout."""
server = await aiohttp_server(app)
url = 'http://localhost:%d/slow_request' % server.port
connector = TCPConnector(timeouts=Timeouts(sock_read=0.2))
async with aiosonic.HTTPClient(connector) as client:
with pytest.raises(ReadTimeout):
await client.get(url)
await server.close()
def __init__(self, pool_size: int = 25, timeouts: Timeouts = None,
connection_cls=None, pool_cls=None):
"""Initialize."""
from aiosonic.connection import Connection # avoid circular dependency
self.pool_size = pool_size
connection_cls = connection_cls or Connection
pool_cls = pool_cls or SmartPool
self.pool = pool_cls(self, pool_size, connection_cls)
self.timeouts = timeouts or Timeouts()
async def test_simple_get(app, aiohttp_server):
"""Test simple get."""
server = await aiohttp_server(app)
url = 'http://localhost:%d' % server.port
connector = TCPConnector(timeouts=Timeouts(sock_connect=3, sock_read=4))
async with aiosonic.HTTPClient(connector) as client:
res = await client.get(url)
assert res.status_code == 200
assert await res.content() == b'Hello, world'
assert await res.text() == 'Hello, world'
await server.close()
async def test_pool_acquire_timeout(app, aiohttp_server, mocker):
"""Test pool acquirere timeout."""
server = await aiohttp_server(app)
url = 'http://localhost:%d/slow_request' % server.port
connector = TCPConnector(pool_size=1, timeouts=Timeouts(pool_acquire=0.3))
with pytest.raises(ConnectionPoolAcquireTimeout):
await asyncio.gather(
aiosonic.get(url, connector=connector),
aiosonic.get(url, connector=connector),
)
await server.close()
async def test_connect_timeout(mocker):
"""Test connect timeout."""
url = 'http://localhost:1234'
async def long_connect(*_args, **_kwargs):
await asyncio.sleep(3)
_connect = mocker.patch('aiosonic.connection.Connection._connect')
_connect.return_value = long_connect()
with pytest.raises(ConnectTimeout):
await aiosonic.get(
url, connector=TCPConnector(timeouts=Timeouts(sock_connect=0.2)))
async def test_get_google_http2():
"""Test simple get."""
url = 'https://www.google.com'
connector = TCPConnector(
timeouts=Timeouts(sock_connect=3, sock_read=4))
res = await aiosonic.get(url, connector=connector, headers={
'user-agent': (
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) '
'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.87 '
'Safari/537.36')
})
assert res.status_code == 200
assert '<title>Google</title>' in await res.text()
async def test_get_with_cookies(app, aiohttp_server):
"""Test simple get."""
server = await aiohttp_server(app)
url = f'http://localhost:{server.port}/cookies'
connector = TCPConnector(timeouts=Timeouts(sock_connect=3, sock_read=4))
async with aiosonic.HTTPClient(connector, handle_cookies=True) as client:
res = await client.get(url)
assert res.status_code == 200
assert res.cookies
# check if server got cookies
res = await client.get(url)
assert await res.text() == 'Got cookies'
await server.close()
async def test_get_python(http2_serv):
"""Test simple get."""
url = http2_serv
connector = TCPConnector(timeouts=Timeouts(sock_connect=3, sock_read=4))
async with aiosonic.HTTPClient(connector) as client:
res = await client.get(
url,
verify=False,
headers={
'user-agent':
('Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:70.0)'
' Gecko/20100101 Firefox/70.0')
},
http2=True)
assert 'Hello World' in await res.text()
async def test_request_timeout(app, aiohttp_server, mocker):
"""Test request timeout."""
server = await aiohttp_server(app)
url = 'http://localhost:%d/post_json' % server.port
async def long_request(*_args, **_kwargs):
await asyncio.sleep(3)
_connect = mocker.patch('aiosonic._do_request', new=long_request)
_connect.return_value = long_request()
connector = TCPConnector(timeouts=Timeouts(request_timeout=0.2))
async with aiosonic.HTTPClient(connector) as client:
with pytest.raises(RequestTimeout):
await client.get(url)
await server.close()
async def test_connect_timeout(mocker):
"""Test connect timeout."""
url = 'http://localhost:1234'
async def long_connect(*_args, **_kwargs):
await asyncio.sleep(3)
async def acquire(*_args, **_kwargs):
return mocker.MagicMock(connect=long_connect)
_connect = mocker.patch('aiosonic.pools.SmartPool.acquire', new=acquire)
# _connect.return_value = long_connect()
connector = TCPConnector(timeouts=Timeouts(sock_connect=0.2))
with pytest.raises(ConnectTimeout):
async with aiosonic.HTTPClient(connector) as client:
await client.get(url)
def __init__(self,
pool_size: int = 25,
timeouts: Timeouts = None,
connection_cls=None,
pool_cls=None,
resolver=None,
ttl_dns_cache=10000,
use_dns_cache=True):
from aiosonic.connection import Connection # avoid circular dependency
self.pool_size = pool_size
connection_cls = connection_cls or Connection
pool_cls = pool_cls or SmartPool
self.pool = pool_cls(self, pool_size, connection_cls)
self.timeouts = timeouts or Timeouts()
self.resolver = resolver or DefaultResolver()
self.use_dns_cache = use_dns_cache
if self.use_dns_cache:
self.cache = ExpirableCache(512, ttl_dns_cache)
