async def test_json_invalid_content_type(loop: Any, session: Any) -> None:
response = ClientResponse(
"get",
URL("http://def-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
response._headers = {"Content-Type": "data/octet-stream"}
response._body = b""
with pytest.raises(aiohttp.ContentTypeError) as info:
await response.json()
assert info.value.request_info == response.request_info
async def test_release(loop: Any, session: Any) -> None:
response = ClientResponse(
"get",
URL("http://def-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
fut = loop.create_future()
fut.set_result(b"")
content = response.content = mock.Mock()
content.readany.return_value = fut
response.release()
assert response._connection is None
async def test_response_eof_upgraded(loop: Any, session: Any) -> None:
response = ClientResponse(
"get",
URL("http://def-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
conn = response._connection = mock.Mock()
conn.protocol.upgraded = True
response._response_eof()
assert not conn.release.called
assert response._connection is conn
def test_response_links_no_rel(loop: Any, session: Any) -> None:
url = URL("http://def-cl-resp.org/")
response = ClientResponse(
"get",
url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
response._headers = CIMultiDict([("Link", "<http://example.com/>")])
assert response.links == {
"http://example.com/": {
"url": URL("http://example.com/")
}
}
def test_response_not_closed_after_get_ok(mocker) -> None:
response = ClientResponse(
"get",
URL("http://del-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=mock.Mock(),
session=mock.Mock(),
)
response.status = 400
response.reason = "Bad Request"
response._closed = False
spy = mocker.spy(response, "raise_for_status")
assert not response.ok
assert not response.closed
assert spy.call_count == 0
def client_response(loop, session):
"""Fixture to return a mocked client response."""
r = aiohttp.ClientResponse(
'get',
URL('http://synse-response.io'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
r.content = mock.Mock()
r._headers = {'Content-Type': 'application/json'}
return r
def cb():
fut = asyncio.Future(loop=self._loop)
resp = ClientResponse('GET',
yarl.URL('foo'),
writer=Mock(),
timer=TimerNoop(),
continue100=None,
request_info=Mock(),
traces=[],
loop=self._loop,
session=Mock())
resp.status = status
# setting this as aiohttp 3.5.4 is now checking if this value is not None
# see aiohttp/client_reqrep.py:934
resp.reason = http.client.responses[status]
fut.set_result(resp)
return fut
def test_content_disposition_full() -> None:
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=mock.Mock(),
session=mock.Mock())
response._headers = {
'Content-Disposition': 'attachment; filename="archive.tar.gz"; foo=bar'
}
assert 'attachment' == response.content_disposition.type
assert 'bar' == response.content_disposition.parameters["foo"]
assert 'archive.tar.gz' == response.content_disposition.filename
with pytest.raises(TypeError):
response.content_disposition.parameters["foo"] = "baz"
def test_https_connect_resp_start_error(self, ClientRequestMock):
proxy_req = ClientRequest('GET',
URL('http://proxy.example.com'),
loop=self.loop)
ClientRequestMock.return_value = proxy_req
proxy_resp = ClientResponse('get',
URL('http://proxy.example.com'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
auto_decompress=True,
traces=[],
loop=self.loop,
session=mock.Mock())
proxy_req.send = make_mocked_coro(proxy_resp)
proxy_resp.start = make_mocked_coro(
raise_exception=OSError("error message"))
connector = aiohttp.TCPConnector(loop=self.loop)
connector._resolve_host = make_mocked_coro([{
'hostname': 'hostname',
'host': '127.0.0.1',
'port': 80,
'family': socket.AF_INET,
'proto': 0,
'flags': 0
}])
tr, proto = mock.Mock(), mock.Mock()
tr.get_extra_info.return_value = None
self.loop.create_connection = make_mocked_coro((tr, proto))
req = ClientRequest(
'GET',
URL('https://www.python.org'),
proxy=URL('http://proxy.example.com'),
loop=self.loop,
)
with self.assertRaisesRegex(OSError, "error message"):
self.loop.run_until_complete(connector._create_connection(req))
async def request(self, *args, **kwargs) -> ClientResponse:
try:
data = self.requests.pop(0)
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=asyncio.get_running_loop(),
session=mock.Mock())
response.status = 200
response._body = data
response._headers = {'Content-Type': 'application/json'}
return response
except IndexError as e:
print(f'error in pop requests')
raise Exception(str(e)) from e
async def test_read_and_release_connection_with_error(loop: Any,
session: Any) -> None:
response = ClientResponse(
"get",
URL("http://def-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
content = response.content = mock.Mock()
content.read.return_value = loop.create_future()
content.read.return_value.set_exception(ValueError)
with pytest.raises(ValueError):
await response.read()
assert response._closed
async def test_response_eof_after_connection_detach(loop: Any,
session: Any) -> None:
response = ClientResponse(
"get",
URL("http://def-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
response._closed = False
conn = response._connection = mock.Mock()
conn.protocol = None
response._response_eof()
assert conn.release.called
assert response._connection is None
def test_response_links_quoted(loop, session):
url = URL('http://def-cl-resp.org/')
response = ClientResponse('get',
url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
response.headers = CIMultiDict([
("Link", '<http://example.com/>; rel="home-page"'),
])
assert (response.links == {
'home-page': {
'url': URL('http://example.com/'),
'rel': 'home-page'
}
})
async def test_json_custom_loader(loop: Any, session: Any) -> None:
response = ClientResponse(
"get",
URL("http://def-cl-resp.org"),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
response._headers = {"Content-Type": "application/json;charset=cp1251"}
response._body = b"data"
def custom(content):
return content + "-custom"
res = await response.json(loads=custom)
assert res == "data-custom"
def test_response_links_relative(loop, session):
url = URL('http://def-cl-resp.org/')
response = ClientResponse('get',
url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
response.headers = CIMultiDict([
("Link", '</relative/path>; rel=rel'),
])
assert (response.links == {
'rel': {
'url': URL('http://def-cl-resp.org/relative/path'),
'rel': 'rel'
}
})
def test_response_request_info() -> None:
url = 'http://def-cl-resp.org'
headers = {'Content-Type': 'application/json;charset=cp1251'}
response = ClientResponse(
'get', URL(url),
request_info=RequestInfo(
url,
'get',
headers
),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=mock.Mock(),
session=mock.Mock()
)
assert url == response.request_info.url
assert 'get' == response.request_info.method
assert headers == response.request_info.headers
async def test_read_and_release_connection(loop, session) -> None:
response = ClientResponse('get', URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result(b'payload')
return fut
content = response.content = mock.Mock()
content.read.side_effect = side_effect
res = await response.read()
assert res == b'payload'
assert response._connection is None
def HTTPResponse(*args, **kw):
# Dynamically load package
module = __import__(RESPONSE_PATH, fromlist=(RESPONSE_CLASS, ))
ClientResponse = getattr(module, RESPONSE_CLASS)
from aiohttp.helpers import TimerNoop
kw['request_info'] = m.Mock(
method=args[0],
url=args[1],
)
kw['writer'] = m.Mock()
kw['continue100'] = None
kw['timer'] = TimerNoop()
kw['traces'] = []
kw['loop'] = m.Mock()
kw['session'] = None
# Return response instance
return ClientResponse(*args, **kw)
async def build_response(
self, url: URL
) -> 'Union[ClientResponse, Exception]':
if isinstance(self.exception, Exception):
return self.exception
kwargs = {}
if AIOHTTP_VERSION >= StrictVersion('3.1.0'):
loop = Mock()
loop.get_debug = Mock()
loop.get_debug.return_value = True
kwargs['request_info'] = Mock()
kwargs['writer'] = Mock()
kwargs['continue100'] = None
kwargs['timer'] = TimerNoop()
if AIOHTTP_VERSION >= StrictVersion('3.3.0'):
pass
else:
kwargs['auto_decompress'] = True
kwargs['traces'] = []
kwargs['loop'] = loop
kwargs['session'] = None
resp = self.response_class(self.method, url, **kwargs)
# we need to initialize headers manually
headers = CIMultiDict({hdrs.CONTENT_TYPE: self.content_type})
if self.headers:
headers.update(self.headers)
raw_headers = self._build_raw_headers(headers)
if AIOHTTP_VERSION >= StrictVersion('3.3.0'):
# Reified attributes
resp._headers = headers
resp._raw_headers = raw_headers
else:
resp.headers = headers
resp.raw_headers = raw_headers
resp.status = self.status
resp.reason = self.reason
resp.content = stream_reader_factory()
resp.content.feed_data(self.body)
resp.content.feed_eof()
return resp
def build_response(self, method: str, url: str, payload: str, *,
session: ClientSession, status: int) -> ClientResponse:
response = session._response_class(
method,
URL(url),
request_info=self.mock_module.Mock(),
writer=self.mock_module.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=session.loop,
session=session)
response._headers = CIMultiDictProxy(
CIMultiDict({'Content-Type': 'application/json'}))
response.status = status
if status >= 400:
response.reason = payload
response.content = StreamReader(ResponseHandler(session.loop))
response.content.feed_data(str.encode(payload))
response.content.feed_eof()
return response
def test_response_links_relative(loop: Any, session: Any) -> None:
url = URL("http://def-cl-resp.org/")
response = ClientResponse(
"get",
url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
response._headers = CIMultiDict([
("Link", "</relative/path>; rel=rel"),
])
assert response.links == {
"rel": {
"url": URL("http://def-cl-resp.org/relative/path"),
"rel": "rel"
}
}
def test_response_links_quoted(loop, session) -> None:
url = URL("http://def-cl-resp.org/")
response = ClientResponse(
"get",
url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session,
)
response._headers = CIMultiDict([
("Link", '<http://example.com/>; rel="home-page"'),
])
assert response.links == {
"home-page": {
"url": URL("http://example.com/"),
"rel": "home-page"
}
}
async def test_json_custom_content_type(loop, session):
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result('{"тест": "пройден"}'.encode('cp1251'))
return fut
response.headers = {'Content-Type': 'custom/type;charset=cp1251'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
res = await response.json(content_type='custom/type')
assert res == {'тест': 'пройден'}
assert response._connection is None
def test_response_links_no_rel(loop, session) -> None:
url = URL('http://def-cl-resp.org/')
response = ClientResponse('get', url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
response._headers = CIMultiDict([
(
"Link",
'<http://example.com/>'
)
])
assert (
response.links ==
{
'http://example.com/':
{'url': URL('http://example.com/')}
}
)
async def test_text_after_read(loop, session) -> None:
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result('{"тест": "пройден"}'.encode('cp1251'))
return fut
response._headers = {'Content-Type': 'application/json;charset=cp1251'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
res = await response.text()
assert res == '{"тест": "пройден"}'
assert response._connection is None
def test_no_redirect_history_in_exception() -> None:
url = 'http://def-cl-resp.org'
headers = {'Content-Type': 'application/json;charset=cp1251'}
response = ClientResponse(
'get',
URL(url),
request_info=RequestInfo(
url,
'get',
headers
),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=mock.Mock(),
session=mock.Mock()
)
response.status = 409
response.reason = 'CONFLICT'
with pytest.raises(aiohttp.ClientResponseError) as cm:
response.raise_for_status()
assert () == cm.value.history
async def test_http_processing_error(session) -> None:
loop = mock.Mock()
request_info = mock.Mock()
response = ClientResponse(
'get', URL('http://del-cl-resp.org'), request_info=request_info,
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
loop.get_debug = mock.Mock()
loop.get_debug.return_value = True
connection = mock.Mock()
connection.protocol = aiohttp.DataQueue(loop)
connection.protocol.set_response_params = mock.Mock()
connection.protocol.set_exception(http.HttpProcessingError())
with pytest.raises(aiohttp.ClientResponseError) as info:
await response.start(connection)
assert info.value.request_info is request_info
def test_del(session) -> None:
loop = mock.Mock()
response = ClientResponse('get', URL('http://del-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
loop.get_debug = mock.Mock()
loop.get_debug.return_value = True
connection = mock.Mock()
response._closed = False
response._connection = connection
loop.set_exception_handler(lambda loop, ctx: None)
with pytest.warns(ResourceWarning):
del response
gc.collect()
connection.release.assert_called_with()
async def test_response_read_triggers_callback(loop: Any,
session: Any) -> None:
trace = mock.Mock()
trace.send_response_chunk_received = make_mocked_coro()
response_method = "get"
response_url = URL("http://def-cl-resp.org")
response_body = b"This is response"
response = ClientResponse(
response_method,
response_url,
request_info=mock.Mock,
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
loop=loop,
session=session,
traces=[trace],
)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result(response_body)
return fut
response._headers = {"Content-Type": "application/json;charset=cp1251"}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
res = await response.read()
assert res == response_body
assert response._connection is None
assert trace.send_response_chunk_received.called
assert trace.send_response_chunk_received.call_args == mock.call(
response_method, response_url, response_body)
async def test_text_detect_encoding_if_invalid_charset(loop, session) -> None:
response = ClientResponse('get', URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=loop,
session=session)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result('{"тест": "пройден"}'.encode('cp1251'))
return fut
response._headers = {'Content-Type': 'text/plain;charset=invalid'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
await response.read()
res = await response.text()
assert res == '{"тест": "пройден"}'
assert response._connection is None
assert response.get_encoding().lower() in ('windows-1251', 'maccyrillic')