def test_no_redirect_history_in_exception():
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(),
auto_decompress=True,
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
def test_json_override_encoding(loop):
response = ClientResponse('get', URL('http://def-cl-resp.org'))
response._post_init(loop)
def side_effect(*args, **kwargs):
fut = helpers.create_future(loop)
fut.set_result('{"тест": "пройден"}'.encode('cp1251'))
return fut
response.headers = {'Content-Type': 'application/json;charset=utf8'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
response._get_encoding = mock.Mock()
res = yield from response.json(encoding='cp1251')
assert res == {'тест': 'пройден'}
assert response._connection is None
assert not response._get_encoding.called
async def test_read_and_release_connection_with_error(loop, session):
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
auto_decompress=True,
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, session):
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
auto_decompress=True,
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
async def test_json_custom_loader(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)
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'
async def test_text_detect_encoding_if_invalid_charset(loop, session):
response = ClientResponse('get', URL('http://def-cl-resp.org'))
response._post_init(loop, 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')
async def test_release(loop, session):
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
auto_decompress=True,
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
def test_response_links_no_rel(loop, session):
url = URL('http://def-cl-resp.org/')
response = ClientResponse('get',
url,
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
auto_decompress=True,
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_custom_encoding(loop, session):
response = ClientResponse('get', URL('http://def-cl-resp.org'))
response._post_init(loop, session)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result('{"тест": "пройден"}'.encode('cp1251'))
return fut
response.headers = {'Content-Type': 'application/json'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
response.get_encoding = mock.Mock()
res = await response.text(encoding='cp1251')
assert res == '{"тест": "пройден"}'
assert response._connection is None
assert not response.get_encoding.called
def test_close(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
response._connection = mock.Mock()
response.close()
assert response.connection is None
response.close()
response.close()
async def test_json_extended_content_type(loop, session):
response = ClientResponse('get', URL('http://def-cl-resp.org'))
response._post_init(loop, session)
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result('{"тест": "пройден"}'.encode('cp1251'))
return fut
response.headers = {
'Content-Type':
'application/this.is-1_content+subtype+json;charset=cp1251'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
res = await response.json()
assert res == {'тест': 'пройден'}
assert response._connection is None
async def test_json_invalid_content_type(loop, session):
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
auto_decompress=True,
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_http_processing_error(session):
loop = mock.Mock()
request_info = mock.Mock()
response = ClientResponse(
'get', URL('http://del-cl-resp.org'), request_info=request_info)
response._post_init(loop, session)
loop.get_debug = mock.Mock()
loop.get_debug.return_value = True
connection = mock.Mock()
connection.protocol = aiohttp.DataQueue(loop=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_https_auth(self, ClientRequestMock):
proxy_req = ClientRequest('GET', URL('http://proxy.example.com'),
auth=aiohttp.helpers.BasicAuth('user',
'pass'),
loop=self.loop)
ClientRequestMock.return_value = proxy_req
proxy_resp = ClientResponse('get', URL('http://proxy.example.com'))
proxy_resp._loop = self.loop
proxy_req.send = send_mock = mock.Mock()
send_mock.return_value = proxy_resp
proxy_resp.start = make_mocked_coro(mock.Mock(status=200))
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()
self.loop.create_connection = make_mocked_coro((tr, proto))
self.assertIn('AUTHORIZATION', proxy_req.headers)
self.assertNotIn('PROXY-AUTHORIZATION', proxy_req.headers)
req = ClientRequest(
'GET', URL('https://www.python.org'),
proxy=URL('http://proxy.example.com'),
loop=self.loop
)
self.assertNotIn('AUTHORIZATION', req.headers)
self.assertNotIn('PROXY-AUTHORIZATION', req.headers)
self.loop.run_until_complete(connector._create_connection(req))
self.assertEqual(req.url.path, '/')
self.assertNotIn('AUTHORIZATION', req.headers)
self.assertNotIn('PROXY-AUTHORIZATION', req.headers)
self.assertNotIn('AUTHORIZATION', proxy_req.headers)
self.assertIn('PROXY-AUTHORIZATION', proxy_req.headers)
connector._resolve_host.assert_called_with('proxy.example.com', 80)
self.loop.run_until_complete(proxy_req.close())
proxy_resp.close()
self.loop.run_until_complete(req.close())
def test_text_bad_encoding(loop):
response = ClientResponse('get', URL('http://def-cl-resp.org'))
response._post_init(loop)
def side_effect(*args, **kwargs):
fut = helpers.create_future(loop)
fut.set_result('{"тестkey": "пройденvalue"}'.encode('cp1251'))
return fut
# lie about the encoding
response.headers = {'Content-Type': 'application/json;charset=utf-8'}
content = response.content = mock.Mock()
content.read.side_effect = side_effect
with pytest.raises(UnicodeDecodeError):
yield from response.text()
# only the valid utf-8 characters will be returned
res = yield from response.text(errors='ignore')
assert res == '{"key": "value"}'
assert response._connection is None
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 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_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
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
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_https_connect_resp_start_error(self, ClientRequestMock) -> None:
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(),
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, None,
aiohttp.ClientTimeout()))
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
def function759(arg791):
var1906 = ResponseHandler(loop=arg791)
var1870 = mock.Mock()
var1906.connection_made(var1870)
var2202 = mock.Mock()
var2202.protocol = var1906
var1906.data_received(b'HTTP/1.1 200 Ok\r\n\r\n')
var1984 = ClientResponse('get', URL('http://def-cl-resp.org'))
var1984._post_init(arg791)
yield from var1984.start(var2202, read_until_eof=True)
assert (not var1984.content.is_eof())
var1906.data_received(b'0000')
var4385 = yield from var1984.content.readany()
assert (var4385 == b'0000')
var1906.data_received(b'1111')
var4385 = yield from var1984.content.readany()
assert (var4385 == b'1111')
var1906.connection_lost(None)
assert var1984.content.is_eof()
def test_raise_for_status_4xx_without_reason() -> 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.status = 404
response.reason = ""
with pytest.raises(aiohttp.ClientResponseError) as cm:
response.raise_for_status()
assert str(cm.value.status) == "404"
assert str(cm.value.message) == ""
assert response.closed
def test_connect_env_var_https_used(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'))
proxy_resp._loop = self.loop
proxy_req.send = send_mock = mock.Mock()
send_mock.return_value = proxy_resp
proxy_resp.start = make_mocked_coro(mock.Mock(status=200))
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()
self.loop.create_connection = make_mocked_coro((tr, proto))
req = ClientRequest(
'GET',
URL('https://www.python.org'),
proxy_from_env=True,
loop=self.loop,
)
self.loop.run_until_complete(connector._create_connection(req))
self.assertEqual(req.url.path, '/')
self.assertEqual(proxy_req.method, 'CONNECT')
self.assertEqual(proxy_req.url, URL('https://www.python.org'))
tr.close.assert_called_once_with()
tr.get_extra_info.assert_called_with('socket', default=None)
self.loop.run_until_complete(proxy_req.close())
proxy_resp.close()
self.loop.run_until_complete(req.close())
self.assertIn('https', getproxies())
def test_content_disposition_full():
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 function1482(self, arg730):
var3149 = ClientRequest('GET',
URL('http://proxy.example.com'),
auth=aiohttp.helpers.BasicAuth('user', 'pass'),
loop=self.attribute501)
arg730.return_value = var3149
var1630 = ClientResponse('get', URL('http://proxy.example.com'))
var1630._loop = self.attribute501
var3149.send = var2291 = mock.Mock()
var2291.return_value = var1630
var1630.start = make_mocked_coro(mock.Mock(status=200))
var3229 = aiohttp.TCPConnector(loop=self.attribute501)
var3229._resolve_host = make_mocked_coro([{
'hostname': 'hostname',
'host': '127.0.0.1',
'port': 80,
'family': socket.AF_INET,
'proto': 0,
'flags': 0,
}])
(var3729, var3324) = (mock.Mock(), mock.Mock())
self.attribute501.create_connection = make_mocked_coro(
(var3729, var3324))
self.assertIn('AUTHORIZATION', var3149.headers)
self.assertNotIn('PROXY-AUTHORIZATION', var3149.headers)
var3369 = ClientRequest('GET',
URL('https://www.python.org'),
proxy=URL('http://proxy.example.com'),
loop=self.attribute501)
self.assertNotIn('AUTHORIZATION', var3369.headers)
self.assertNotIn('PROXY-AUTHORIZATION', var3369.headers)
self.attribute501.run_until_complete(
var3229._create_connection(var3369))
self.assertEqual(var3369.url.path, '/')
self.assertNotIn('AUTHORIZATION', var3369.headers)
self.assertNotIn('PROXY-AUTHORIZATION', var3369.headers)
self.assertNotIn('AUTHORIZATION', var3149.headers)
self.assertIn('PROXY-AUTHORIZATION', var3149.headers)
var3229._resolve_host.assert_called_with('proxy.example.com', 80)
self.attribute501.run_until_complete(var3149.close())
var1630.close()
self.attribute501.run_until_complete(var3369.close())
def test_https_connect_pass_ssl_context(self, ClientRequestMock):
loop_mock = _create_mocked_loop()
proxy_req = ClientRequest('GET',
'http://proxy.example.com',
loop=loop_mock)
ClientRequestMock.return_value = proxy_req
proxy_resp = ClientResponse('get', 'http://proxy.example.com')
proxy_resp._loop = loop_mock
proxy_req.send = send_mock = unittest.mock.Mock()
send_mock.return_value = proxy_resp
proxy_resp.start = start_mock = unittest.mock.Mock()
self._fake_coroutine(start_mock, unittest.mock.Mock(status=200))
connector = aiohttp.TCPConnector(loop=loop_mock)
tr, proto = unittest.mock.Mock(), unittest.mock.Mock()
self._fake_coroutine(loop_mock.create_connection, (tr, proto))
req = ClientRequest(
'GET',
'https://www.python.org',
proxy='http://proxy.example.com',
loop=self.loop,
)
self.loop.run_until_complete(connector._create_connection(req))
loop_mock.create_connection.assert_called_with(
mock.ANY,
ssl=connector.ssl_context,
sock=mock.ANY,
server_hostname='www.python.org')
self.assertEqual(req.path, '/')
self.assertEqual(proxy_req.method, 'CONNECT')
self.assertEqual(proxy_req.path, 'www.python.org:443')
tr.pause_reading.assert_called_once_with()
tr.get_extra_info.assert_called_with('socket', default=None)
self.loop.run_until_complete(proxy_req.close())
proxy_resp.close()
self.loop.run_until_complete(req.close())
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_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'
}
})
