def test_urlencoded_formdata_charset(loop, conn):
req = ClientRequest(
'post', URL('http://python.org'),
data=aiohttp.FormData({'hey': 'you'}, charset='koi8-r'), loop=loop)
req.send(conn)
assert 'application/x-www-form-urlencoded; charset=koi8-r' == \
req.headers.get('CONTENT-TYPE')
async def test_data_stream_exc_chain(loop, conn):
fut = loop.create_future()
@aiohttp.streamer
async def gen(writer):
await fut
req = ClientRequest('POST', URL('http://python.org/'),
data=gen(), loop=loop)
inner_exc = ValueError()
async def throw_exc():
await asyncio.sleep(0.01, loop=loop)
fut.set_exception(inner_exc)
loop.create_task(throw_exc())
req.send(conn)
await req._writer
# assert connection.close.called
assert conn.protocol.set_exception.called
outer_exc = conn.protocol.set_exception.call_args[0][0]
assert isinstance(outer_exc, ValueError)
assert inner_exc is outer_exc
assert inner_exc is outer_exc
await req.close()
def test_data_stream_exc(loop, conn):
fut = helpers.create_future(loop)
@aiohttp.streamer
def gen(writer):
writer.write(b'binary data')
yield from fut
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(), loop=loop)
assert req.chunked
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
@asyncio.coroutine
def exc():
yield from asyncio.sleep(0.01, loop=loop)
fut.set_exception(ValueError)
helpers.ensure_future(exc(), loop=loop)
req.send(conn)
yield from req._writer
# assert conn.close.called
assert conn.protocol.set_exception.called
yield from req.close()
def test_data_stream_continue(self):
def gen():
yield b'binary data'
return b' result'
req = ClientRequest(
'POST', 'http://python.org/', data=gen(),
expect100=True, loop=self.loop)
self.assertTrue(req.chunked)
self.assertTrue(inspect.isgenerator(req.body))
def coro():
yield from asyncio.sleep(0.0001, loop=self.loop)
req._continue.set_result(1)
asyncio.async(coro(), loop=self.loop)
req.send(self.transport, self.protocol)
self.loop.run_until_complete(req._writer)
self.assertEqual(
self.transport.write.mock_calls[-3:],
[unittest.mock.call(b'binary data result'),
unittest.mock.call(b'\r\n'),
unittest.mock.call(b'0\r\n\r\n')])
self.loop.run_until_complete(req.close())
def test_data_stream_exc(loop):
fut = helpers.create_future(loop)
def gen():
yield b'binary data'
yield from fut
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(), loop=loop)
assert req.chunked
assert inspect.isgenerator(req.body)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
@asyncio.coroutine
def exc():
yield from asyncio.sleep(0.01, loop=loop)
fut.set_exception(ValueError)
helpers.ensure_future(exc(), loop=loop)
conn = mock.Mock(acquire=acquire)
req.send(conn)
yield from req._writer
# assert conn.close.called
assert conn.protocol.set_exception.called
yield from req.close()
def test_content_type_auto_header_content_length_no_skip(self):
req = ClientRequest('get', 'http://python.org',
data=io.BytesIO(b'hey'),
skip_auto_headers={'CONTENT-LENGTH'},
loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual(req.headers.get('CONTENT-LENGTH'), '3')
def test_data_stream_exc_chain(loop, conn):
fut = helpers.create_future(loop)
@aiohttp.streamer
def gen(writer):
yield from fut
req = ClientRequest('POST', URL('http://python.org/'),
data=gen(), loop=loop)
inner_exc = ValueError()
@asyncio.coroutine
def exc():
yield from asyncio.sleep(0.01, loop=loop)
fut.set_exception(inner_exc)
helpers.ensure_future(exc(), loop=loop)
req.send(conn)
yield from req._writer
# assert connection.close.called
assert conn.protocol.set_exception.called
outer_exc = conn.protocol.set_exception.call_args[0][0]
assert isinstance(outer_exc, ValueError)
assert inner_exc is outer_exc
assert inner_exc is outer_exc
yield from req.close()
def test_chunked_length(self):
req = ClientRequest(
'get', 'http://python.org/',
headers={'CONTENT-LENGTH': '1000'}, chunked=1024, loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual(req.headers['TRANSFER-ENCODING'], 'chunked')
self.assertNotIn('CONTENT-LENGTH', req.headers)
self.loop.run_until_complete(req.close())
def test_chunked_explicit_size(self, m_http):
req = ClientRequest(
'get', 'http://python.org/', chunked=1024, loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('chunked', req.headers['TRANSFER-ENCODING'])
m_http.Request.return_value\
.add_chunking_filter.assert_called_with(1024)
self.loop.run_until_complete(req.close())
def test_content_encoding(self, m_http):
req = ClientRequest('get', 'http://python.org/',
compress='deflate', loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual(req.headers['TRANSFER-ENCODING'], 'chunked')
self.assertEqual(req.headers['CONTENT-ENCODING'], 'deflate')
m_http.Request.return_value\
.add_compression_filter.assert_called_with('deflate')
self.loop.run_until_complete(req.close())
def test_terminate(self):
req = ClientRequest('get', 'http://python.org', loop=self.loop)
req.send(self.transport, self.protocol)
self.assertIsNotNone(req._writer)
writer = req._writer = unittest.mock.Mock()
req.terminate()
self.assertIsNone(req._writer)
writer.cancel.assert_called_with()
def test_no_content_length(self):
req = ClientRequest('get', 'http://python.org', loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('0', req.headers.get('CONTENT-LENGTH'))
self.loop.run_until_complete(req.close())
req = ClientRequest('head', 'http://python.org', loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('0', req.headers.get('CONTENT-LENGTH'))
self.loop.run_until_complete(req.close())
def test_bytes_data(self):
for meth in ClientRequest.POST_METHODS:
req = ClientRequest(
meth, 'http://python.org/',
data=b'binary data', loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('/', req.path)
self.assertEqual(b'binary data', req.body)
self.assertEqual('application/octet-stream',
req.headers['CONTENT-TYPE'])
self.loop.run_until_complete(req.close())
def test_post_data(self):
for meth in ClientRequest.POST_METHODS:
req = ClientRequest(
meth, 'http://python.org/',
data={'life': '42'}, loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('/', req.path)
self.assertEqual(b'life=42', req.body)
self.assertEqual('application/x-www-form-urlencoded',
req.headers['CONTENT-TYPE'])
self.loop.run_until_complete(req.close())
def test_data_stream_not_bytes(self):
@asyncio.coroutine
def gen():
yield object()
req = ClientRequest(
'POST', 'http://python.org/', data=gen(), loop=self.loop)
req.send(self.transport, self.protocol)
self.loop.run_until_complete(req._writer)
self.assertTrue(self.protocol.set_exception.called)
self.loop.run_until_complete(req.close())
def test_no_content_length(self):
req = ClientRequest("get", "http://python.org", loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual("0", req.headers.get("CONTENT-LENGTH"))
self.loop.run_until_complete(req.close())
resp.close()
req = ClientRequest("head", "http://python.org", loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual("0", req.headers.get("CONTENT-LENGTH"))
self.loop.run_until_complete(req.close())
resp.close()
def test_terminate_with_closed_loop(self):
if not hasattr(self.loop, 'is_closed'):
self.skipTest("Required asyncio 3.4.2+")
req = ClientRequest('get', 'http://python.org', loop=self.loop)
req.send(self.transport, self.protocol)
self.assertIsNotNone(req._writer)
writer = req._writer = unittest.mock.Mock()
self.loop.close()
req.terminate()
self.assertIsNone(req._writer)
self.assertFalse(writer.cancel.called)
def test_chunked(self):
req = ClientRequest("get", "http://python.org/", headers={"TRANSFER-ENCODING": "gzip"}, loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual("gzip", req.headers["TRANSFER-ENCODING"])
self.loop.run_until_complete(req.close())
resp.close()
req = ClientRequest("get", "http://python.org/", headers={"Transfer-encoding": "chunked"}, loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual("chunked", req.headers["TRANSFER-ENCODING"])
self.loop.run_until_complete(req.close())
resp.close()
def _test_connect_request_with_unicode_host(self, Request_mock):
loop = mock.Mock()
request = ClientRequest("CONNECT", URL("http://éé.com/"),
loop=loop)
request.response_class = mock.Mock()
request.write_bytes = mock.Mock()
request.write_bytes.return_value = asyncio.Future(loop=loop)
request.write_bytes.return_value.set_result(None)
request.send(mock.Mock())
Request_mock.assert_called_with(mock.ANY, mock.ANY, "xn--9caa.com:80",
mock.ANY, loop=loop)
def test_chunked(self):
req = ClientRequest(
'get', 'http://python.org/',
headers={'TRANSFER-ENCODING': 'gzip'}, loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('gzip', req.headers['TRANSFER-ENCODING'])
self.loop.run_until_complete(req.close())
req = ClientRequest(
'get', 'http://python.org/',
headers={'Transfer-encoding': 'chunked'}, loop=self.loop)
req.send(self.transport, self.protocol)
self.assertEqual('chunked', req.headers['TRANSFER-ENCODING'])
self.loop.run_until_complete(req.close())
def test_content_encoding_dont_set_headers_if_no_body(self, m_http):
req = ClientRequest("get", "http://python.org/", compress="deflate", loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertNotIn("TRANSFER-ENCODING", req.headers)
self.assertNotIn("CONTENT-ENCODING", req.headers)
self.loop.run_until_complete(req.close())
resp.close()
def test_expect_100_continue_header(self):
req = ClientRequest("get", "http://python.org/", headers={"expect": "100-continue"}, loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual("100-continue", req.headers["EXPECT"])
self.assertIsNotNone(req._continue)
req.terminate()
resp.close()
def test_content_type_auto_header_form(loop, conn):
req = ClientRequest('post', URL('http://python.org'),
data={'hey': 'you'}, loop=loop)
resp = req.send(conn)
assert 'application/x-www-form-urlencoded' == \
req.headers.get('CONTENT-TYPE')
resp.close()
def test_data_stream_continue(loop):
def gen():
yield b'binary data'
return b' result'
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(),
expect100=True, loop=loop)
assert req.chunked
assert inspect.isgenerator(req.body)
def coro():
yield from asyncio.sleep(0.0001, loop=loop)
req._continue.set_result(1)
helpers.ensure_future(coro(), loop=loop)
transport = mock.Mock()
resp = req.send(transport, mock.Mock())
yield from req._writer
assert transport.write.mock_calls[-2:] == [
mock.call(b'12\r\nbinary data result\r\n'),
mock.call(b'0\r\n\r\n')]
yield from req.close()
resp.close()
def test_data_stream_exc_chain(loop):
fut = helpers.create_future(loop)
def gen():
yield from fut
req = ClientRequest('POST', URL('http://python.org/'),
data=gen(), loop=loop)
inner_exc = ValueError()
@asyncio.coroutine
def exc():
yield from asyncio.sleep(0.01, loop=loop)
fut.set_exception(inner_exc)
helpers.ensure_future(exc(), loop=loop)
protocol = mock.Mock()
resp = req.send(mock.Mock(), protocol)
connection = mock.Mock()
resp._connection = connection
yield from req._writer
assert connection.close.called
assert protocol.set_exception.called
outer_exc = protocol.set_exception.call_args[0][0]
assert isinstance(outer_exc, aiohttp.ClientRequestError)
assert inner_exc is outer_exc.__context__
assert inner_exc is outer_exc.__cause__
yield from req.close()
def test_content_type_skip_auto_header_form(loop, conn):
req = ClientRequest('post', URL('http://python.org'),
data={'hey': 'you'}, loop=loop,
skip_auto_headers={'Content-Type'})
resp = req.send(conn)
assert 'CONTENT-TYPE' not in req.headers
resp.close()
def test_data_stream_exc(self):
fut = helpers.create_future(self.loop)
def gen():
yield b"binary data"
yield from fut
req = ClientRequest("POST", "http://python.org/", data=gen(), loop=self.loop)
self.assertTrue(req.chunked)
self.assertTrue(inspect.isgenerator(req.body))
self.assertEqual(req.headers["TRANSFER-ENCODING"], "chunked")
@asyncio.coroutine
def exc():
yield from asyncio.sleep(0.01, loop=self.loop)
fut.set_exception(ValueError)
asyncio.async(exc(), loop=self.loop)
resp = req.send(self.transport, self.protocol)
resp._connection = self.connection
self.loop.run_until_complete(req._writer)
self.assertTrue(self.connection.close.called)
self.assertTrue(self.protocol.set_exception.called)
self.loop.run_until_complete(req.close())
def test_content_type_auto_header_content_length_no_skip(self):
req = ClientRequest(
"get", "http://python.org", data=io.BytesIO(b"hey"), skip_auto_headers={"CONTENT-LENGTH"}, loop=self.loop
)
resp = req.send(self.transport, self.protocol)
self.assertEqual(req.headers.get("CONTENT-LENGTH"), "3")
resp.close()
def test_data_stream_exc_chain(self):
fut = helpers.create_future(self.loop)
def gen():
yield from fut
req = ClientRequest("POST", "http://python.org/", data=gen(), loop=self.loop)
inner_exc = ValueError()
@asyncio.coroutine
def exc():
yield from asyncio.sleep(0.01, loop=self.loop)
fut.set_exception(inner_exc)
asyncio.async(exc(), loop=self.loop)
resp = req.send(self.transport, self.protocol)
resp._connection = self.connection
self.loop.run_until_complete(req._writer)
self.assertTrue(self.connection.close.called)
self.assertTrue(self.protocol.set_exception.called)
outer_exc = self.protocol.set_exception.call_args[0][0]
self.assertIsInstance(outer_exc, aiohttp.ClientRequestError)
self.assertIs(inner_exc, outer_exc.__context__)
self.assertIs(inner_exc, outer_exc.__cause__)
self.loop.run_until_complete(req.close())
def test_content_type_skip_auto_header_form(self):
req = ClientRequest(
"post", "http://python.org", data={"hey": "you"}, loop=self.loop, skip_auto_headers={"CONTENT-TYPE"}
)
resp = req.send(self.transport, self.protocol)
self.assertNotIn("CONTENT-TYPE", req.headers)
resp.close()
def test_content_encoding_header(loop):
req = ClientRequest('get',
URL('http://python.org/'),
data='foo',
headers={'Content-Encoding': 'deflate'},
loop=loop)
with mock.patch('aiohttp.client_reqrep.aiohttp') as m_http:
resp = req.send(mock.Mock(), mock.Mock())
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
assert req.headers['CONTENT-ENCODING'] == 'deflate'
m_http.Request.return_value\
.add_compression_filter.assert_called_with('deflate')
m_http.Request.return_value\
.add_chunking_filter.assert_called_with(8192)
yield from req.close()
resp.close()
def function808(arg1474, function1845, function2369):
var2354 = ClientRequest('POST',
URL('http://python.org/'),
data=b'data',
expect100=True,
loop=arg1474)
def function587():
yield from asyncio.sleep(0.0001, loop=arg1474)
var2354._continue.set_result(1)
helpers.ensure_future(function587(), loop=arg1474)
var3880 = var2354.send(function2369)
yield from var2354._writer
assert (function1845.split(b'\r\n\r\n', 1)[1] == b'data')
yield from var2354.close()
var3880.close()
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"))
async def make_conn():
return aiohttp.TCPConnector()
connector = self.loop.run_until_complete(make_conn())
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()))
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 = make_mocked_coro(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,
traces=None)
self.loop.run_until_complete(proxy_req.close())
proxy_resp.close()
self.loop.run_until_complete(req.close())
async def test_data_continue(loop, buf, conn):
req = ClientRequest(
'POST', URL('http://python.org/'), data=b'data',
expect100=True, loop=loop)
async def coro():
await asyncio.sleep(0.0001, loop=loop)
req._continue.set_result(1)
loop.create_task(coro())
resp = req.send(conn)
await req._writer
assert buf.split(b'\r\n\r\n', 1)[1] == b'data'
await req.close()
resp.close()
def test_https_connect_runtime_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(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()
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(
RuntimeError, "Transport does not expose socket instance"):
self.loop.run_until_complete(connector._create_connection(req))
self.loop.run_until_complete(proxy_req.close())
proxy_resp.close()
self.loop.run_until_complete(req.close())
def test_close(self):
@asyncio.coroutine
def gen():
yield from asyncio.sleep(0.00001, loop=self.loop)
return b'result'
req = ClientRequest('POST',
'http://python.org/',
data=gen(),
loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.loop.run_until_complete(req.close())
self.assertEqual(
self.transport.write.mock_calls[-2:],
[mock.call(b'6\r\nresult\r\n'),
mock.call(b'0\r\n\r\n')])
self.loop.run_until_complete(req.close())
resp.close()
def test_data_file(self):
req = ClientRequest('POST',
'http://python.org/',
data=io.BufferedReader(io.BytesIO(b'*' * 2)),
loop=self.loop)
self.assertTrue(req.chunked)
self.assertTrue(isinstance(req.body, io.IOBase))
self.assertEqual(req.headers['TRANSFER-ENCODING'], 'chunked')
resp = req.send(self.transport, self.protocol)
self.assertIsInstance(req._writer, asyncio.Future)
self.loop.run_until_complete(resp.wait_for_close())
self.assertIsNone(req._writer)
self.assertEqual(self.transport.write.mock_calls[-2:], [
mock.call(b'2\r\n' + b'*' * 2 + b'\r\n'),
mock.call(b'0\r\n\r\n')
])
self.loop.run_until_complete(req.close())
def test_data_file(loop, transport):
req = ClientRequest('POST',
URL('http://python.org/'),
data=io.BufferedReader(io.BytesIO(b'*' * 2)),
loop=loop)
assert req.chunked
assert isinstance(req.body, io.IOBase)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
transport, buf = transport
resp = req.send(transport)
assert isinstance(req._writer, asyncio.Future)
yield from resp.wait_for_close()
assert req._writer is None
assert buf.split(b'\r\n\r\n', 1)[1] == \
b'2\r\n' + b'*' * 2 + b'\r\n0\r\n\r\n'
yield from req.close()
async def test_data_stream(loop, buf, conn):
@aiohttp.streamer
def gen(writer):
writer.write(b'binary data')
writer.write(b' result')
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(), loop=loop)
assert req.chunked
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
resp = req.send(conn)
assert asyncio.isfuture(req._writer)
await resp.wait_for_close()
assert req._writer is None
assert buf.split(b'\r\n\r\n', 1)[1] == \
b'b\r\nbinary data\r\n7\r\n result\r\n0\r\n\r\n'
await req.close()
def test_close(loop):
@asyncio.coroutine
def gen():
yield from asyncio.sleep(0.00001, loop=loop)
return b'result'
req = ClientRequest('POST',
URL('http://python.org/'),
data=gen(),
loop=loop)
transport = mock.Mock()
resp = req.send(transport, mock.Mock())
yield from req.close()
assert transport.write.mock_calls[-2:] == [
mock.call(b'6\r\nresult\r\n'),
mock.call(b'0\r\n\r\n')
]
yield from req.close()
resp.close()
def test_data_file(loop):
req = ClientRequest('POST',
URL('http://python.org/'),
data=io.BufferedReader(io.BytesIO(b'*' * 2)),
loop=loop)
assert req.chunked
assert isinstance(req.body, io.IOBase)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
transport = mock.Mock()
resp = req.send(transport, mock.Mock())
assert isinstance(req._writer, asyncio.Future)
yield from resp.wait_for_close()
assert req._writer is None
assert transport.write.mock_calls[-2:] == [
mock.call(b'2\r\n' + b'*' * 2 + b'\r\n'),
mock.call(b'0\r\n\r\n')
]
yield from req.close()
def test_data_continue(loop, buf, conn):
req = ClientRequest('POST',
URL('http://python.org/'),
data=b'data',
expect100=True,
loop=loop)
def coro():
yield from asyncio.sleep(0.0001, loop=loop)
req._continue.set_result(1)
helpers.ensure_future(coro(), loop=loop)
resp = req.send(conn)
yield from req._writer
assert buf.split(b'\r\n\r\n', 1)[1] == b'data'
yield from req.close()
resp.close()
def function366(arg136, function1845, function2369):
@aiohttp.streamer
def function200(arg644):
arg644.function1694(b'binary data')
arg644.function1694(b' result')
var3082 = ClientRequest('POST',
URL('http://python.org/'),
data=function200(),
loop=arg136)
assert var3082.chunked
assert (var3082.headers['TRANSFER-ENCODING'] == 'chunked')
var4479 = var3082.send(function2369)
assert helpers.isfuture(var3082._writer)
yield from var4479.wait_for_close()
assert (var3082._writer is None)
assert (function1845.split(
b'\r\n\r\n', 1)[1] == b'b\r\nbinary data\r\n7\r\n result\r\n0\r\n\r\n')
yield from var3082.close()
def test_data_continue(self):
req = ClientRequest(
'POST', 'http://python.org/', data=b'data',
expect100=True, loop=self.loop)
def coro():
yield from asyncio.sleep(0.0001, loop=self.loop)
req._continue.set_result(1)
asyncio.async(coro(), loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual(1, len(self.transport.write.mock_calls))
self.loop.run_until_complete(req._writer)
self.assertEqual(
self.transport.write.mock_calls[-1],
unittest.mock.call(b'data'))
self.loop.run_until_complete(req.close())
resp.close()
def test_data_stream(self):
def gen():
yield b'binary data'
return b' result'
req = ClientRequest(
'POST', 'http://python.org/', data=gen(), loop=self.loop)
self.assertTrue(req.chunked)
self.assertTrue(inspect.isgenerator(req.body))
self.assertEqual(req.headers['TRANSFER-ENCODING'], 'chunked')
resp = req.send(self.transport, self.protocol)
self.assertIsInstance(req._writer, asyncio.Future)
self.loop.run_until_complete(resp.wait_for_close())
self.assertIsNone(req._writer)
self.assertEqual(
self.transport.write.mock_calls[-2:],
[unittest.mock.call(b'12\r\nbinary data result\r\n'),
unittest.mock.call(b'0\r\n\r\n')])
self.loop.run_until_complete(req.close())
def test_data_continue(loop):
req = ClientRequest('POST',
URL('http://python.org/'),
data=b'data',
expect100=True,
loop=loop)
def coro():
yield from asyncio.sleep(0.0001, loop=loop)
req._continue.set_result(1)
helpers.ensure_future(coro(), loop=loop)
transport = mock.Mock()
resp = req.send(transport, mock.Mock())
assert 1 == len(transport.write.mock_calls)
yield from req._writer
assert transport.write.mock_calls[-1] == mock.call(b'data')
yield from req.close()
resp.close()
def test_https_connect_pass_ssl_context(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 = make_mocked_coro(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=URL('http://proxy.example.com'),
loop=self.loop,
)
self.loop.run_until_complete(connector._create_connection(req))
self.loop.create_connection.assert_called_with(
mock.ANY,
ssl=connector._make_ssl_context(True),
sock=mock.ANY,
server_hostname='www.python.org')
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())
def test_https_connect_ssl_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'))
proxy_resp._loop = self.loop
proxy_req.send = make_mocked_coro(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}])
seq = 0
@asyncio.coroutine
def create_connection(*args, **kwargs):
nonlocal seq
seq += 1
# connection to http://proxy.example.com
if seq == 1:
return mock.Mock(), mock.Mock()
# connection to https://www.python.org
elif seq == 2:
raise ssl.SSLError
else:
assert False
self.loop.create_connection = create_connection
req = ClientRequest(
'GET', URL('https://www.python.org'),
proxy=URL('http://proxy.example.com'),
loop=self.loop,
)
with self.assertRaises(aiohttp.ClientConnectorSSLError):
self.loop.run_until_complete(connector._create_connection(req))
def test_data_stream(loop):
def gen():
yield b'binary data'
return b' result'
req = ClientRequest('POST',
URL('http://python.org/'),
data=gen(),
loop=loop)
assert req.chunked
assert inspect.isgenerator(req.body)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
transport = mock.Mock()
resp = req.send(transport, mock.Mock())
assert isinstance(req._writer, asyncio.Future)
yield from resp.wait_for_close()
assert req._writer is None
assert transport.write.mock_calls[-2:] == [
mock.call(b'12\r\nbinary data result\r\n'),
mock.call(b'0\r\n\r\n')
]
yield from req.close()
def test_data_stream(loop, transport):
def gen():
yield b'binary data'
return b' result'
req = ClientRequest('POST',
URL('http://python.org/'),
data=gen(),
loop=loop)
assert req.chunked
assert inspect.isgenerator(req.body)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
transport, buf = transport
resp = req.send(transport)
assert isinstance(req._writer, asyncio.Future)
yield from resp.wait_for_close()
assert req._writer is None
assert buf.split(b'\r\n\r\n', 1)[1] == \
b'b\r\nbinary data\r\n7\r\n result\r\n0\r\n\r\n'
yield from req.close()
def function615(arg1413, function2369):
var3576 = ClientRequest('get', URL('http://python.org'), loop=arg1413)
var3576.keep_alive = mock.Mock()
var3576.headers.clear()
var3576.keep_alive.return_value = True
var3576.version = (1, 1)
var3576.headers.clear()
var3576.send(function2369)
assert (var3576.headers.get('CONNECTION') is None)
var3576.version = (1, 0)
var3576.headers.clear()
var3576.send(function2369)
assert (var3576.headers.get('CONNECTION') == 'keep-alive')
var3576.keep_alive.return_value = False
var3576.version = (1, 1)
var3576.headers.clear()
var3576.send(function2369)
assert (var3576.headers.get('CONNECTION') == 'close')
async def test_data_stream_continue(loop, buf, conn):
@aiohttp.streamer
async def gen(writer):
writer.write(b'binary data')
writer.write(b' result')
await writer.write_eof()
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(),
expect100=True, loop=loop)
assert req.chunked
async def coro():
await asyncio.sleep(0.0001, loop=loop)
req._continue.set_result(1)
loop.create_task(coro())
resp = req.send(conn)
await req._writer
assert buf.split(b'\r\n\r\n', 1)[1] == \
b'b\r\nbinary data\r\n7\r\n result\r\n0\r\n\r\n'
await req.close()
resp.close()
def test_data_stream_continue(loop, buf, conn):
@aiohttp.streamer
def gen(writer):
writer.write(b'binary data')
writer.write(b' result')
yield from writer.write_eof()
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(),
expect100=True, loop=loop)
assert req.chunked
def coro():
yield from asyncio.sleep(0.0001, loop=loop)
req._continue.set_result(1)
helpers.ensure_future(coro(), loop=loop)
resp = req.send(conn)
yield from req._writer
assert buf.split(b'\r\n\r\n', 1)[1] == \
b'b\r\nbinary data\r\n7\r\n result\r\n0\r\n\r\n'
yield from req.close()
resp.close()
def test_connection_header(loop, conn):
req = ClientRequest('get', URL('http://python.org'), loop=loop)
req.keep_alive = mock.Mock()
req.headers.clear()
req.keep_alive.return_value = True
req.version = (1, 1)
req.headers.clear()
req.send(conn)
assert req.headers.get('CONNECTION') is None
req.version = (1, 0)
req.headers.clear()
req.send(conn)
assert req.headers.get('CONNECTION') == 'keep-alive'
req.keep_alive.return_value = False
req.version = (1, 1)
req.headers.clear()
req.send(conn)
assert req.headers.get('CONNECTION') == 'close'
def test_https_auth(self, ClientRequestMock: Any) -> None:
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"),
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(mock.Mock(status=200))
async def make_conn():
return aiohttp.TCPConnector()
connector = self.loop.run_until_complete(make_conn())
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, None, aiohttp.ClientTimeout()))
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,
traces=mock.ANY)
self.loop.run_until_complete(proxy_req.close())
proxy_resp.close()
self.loop.run_until_complete(req.close())
def test_https_connect_pass_ssl_context(self,
ClientRequestMock: Any) -> 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(mock.Mock(status=200))
async def make_conn():
return aiohttp.TCPConnector()
connector = self.loop.run_until_complete(make_conn())
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=URL("http://proxy.example.com"),
loop=self.loop,
)
self.loop.run_until_complete(
connector._create_connection(req, None, aiohttp.ClientTimeout()))
self.loop.create_connection.assert_called_with(
mock.ANY,
ssl=connector._make_ssl_context(True),
sock=mock.ANY,
server_hostname="www.python.org",
)
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())
def test_https_connect_certificate_error(self,
ClientRequestMock: Any) -> 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(mock.Mock(status=200))
async def make_conn():
return aiohttp.TCPConnector()
connector = self.loop.run_until_complete(make_conn())
connector._resolve_host = make_mocked_coro([{
"hostname": "hostname",
"host": "127.0.0.1",
"port": 80,
"family": socket.AF_INET,
"proto": 0,
"flags": 0,
}])
seq = 0
async def create_connection(*args, **kwargs):
nonlocal seq
seq += 1
# connection to http://proxy.example.com
if seq == 1:
return mock.Mock(), mock.Mock()
# connection to https://www.python.org
elif seq == 2:
raise ssl.CertificateError
else:
assert False
self.loop.create_connection = create_connection
req = ClientRequest(
"GET",
URL("https://www.python.org"),
proxy=URL("http://proxy.example.com"),
loop=self.loop,
)
with self.assertRaises(aiohttp.ClientConnectorCertificateError):
self.loop.run_until_complete(
connector._create_connection(req, None,
aiohttp.ClientTimeout()))
def test_content_type_auto_header_get(loop):
req = ClientRequest('get', URL('http://python.org'), loop=loop)
resp = req.send(mock.Mock(), mock.Mock())
assert 'CONTENT-TYPE' not in req.headers
resp.close()
def test_no_content_length2(loop):
req = ClientRequest('head', URL('http://python.org'), loop=loop)
resp = req.send(mock.Mock(), mock.Mock())
assert '0' == req.headers.get('CONTENT-LENGTH')
yield from req.close()
resp.close()
