def test_https_connect_runtime_error(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()
tr.get_extra_info.return_value = None
self._fake_coroutine(loop_mock.create_connection, (tr, proto))
req = ClientRequest(
'GET', 'https://www.python.org',
proxy='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_https_connect(self, ClientRequestMock):
loop_mock = unittest.mock.Mock()
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.ProxyConnector(
'http://proxy.example.com', 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', loop=self.loop)
self.loop.run_until_complete(connector._create_connection(req))
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_https_connect_http_proxy_error(self, ClientRequestMock):
loop_mock = unittest.mock.Mock()
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=400, reason='bad request'))
connector = aiohttp.ProxyConnector(
'http://proxy.example.com', loop=loop_mock)
tr, proto = unittest.mock.Mock(), unittest.mock.Mock()
tr.get_extra_info.return_value = None
self._fake_coroutine(loop_mock.create_connection, (tr, proto))
req = ClientRequest('GET', 'https://www.python.org', loop=self.loop)
with self.assertRaisesRegex(
aiohttp.HttpProxyError, "400, message='bad request'"):
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_https_connect(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=URL('http://proxy.example.com'),
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.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_https_connect_http_proxy_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 = send_mock = mock.Mock()
send_mock.return_value = proxy_resp
proxy_resp.start = make_mocked_coro(
mock.Mock(status=400, reason='bad request'))
connector = aiohttp.TCPConnector(loop=self.loop)
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(
aiohttp.HttpProxyError, "400, message='bad request'"):
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_params_are_added_before_fragment(self):
req = ClientRequest("GET", "http://example.com/path#fragment", params={"a": "b"}, loop=self.loop)
self.assertEqual(req.path, "/path?a=b#fragment")
self.loop.run_until_complete(req.close())
req = ClientRequest("GET", "http://example.com/path?key=value#fragment", params={"a": "b"}, loop=self.loop)
self.assertEqual(req.path, "/path?key=value&a=b#fragment")
self.loop.run_until_complete(req.close())
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_https_auth(self, ClientRequestMock) -> 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_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_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_method(self):
req = ClientRequest("get", "http://python.org/", loop=self.loop)
self.assertEqual(req.method, "GET")
self.loop.run_until_complete(req.close())
req = ClientRequest("head", "http://python.org/", loop=self.loop)
self.assertEqual(req.method, "HEAD")
self.loop.run_until_complete(req.close())
req = ClientRequest("HEAD", "http://python.org/", loop=self.loop)
self.assertEqual(req.method, "HEAD")
self.loop.run_until_complete(req.close())
def test_method(self):
req = ClientRequest('get', 'http://python.org/', loop=self.loop)
self.assertEqual(req.method, 'GET')
self.loop.run_until_complete(req.close())
req = ClientRequest('head', 'http://python.org/', loop=self.loop)
self.assertEqual(req.method, 'HEAD')
self.loop.run_until_complete(req.close())
req = ClientRequest('HEAD', 'http://python.org/', loop=self.loop)
self.assertEqual(req.method, 'HEAD')
self.loop.run_until_complete(req.close())
def test_websocket_host_port(self):
req = ClientRequest('get', 'ws://python.org/', loop=self.loop)
self.assertEqual(req.host, 'python.org')
self.assertEqual(req.port, 80)
self.assertFalse(req.ssl)
self.loop.run_until_complete(req.close())
req = ClientRequest('get', 'wss://python.org/', loop=self.loop)
self.assertEqual(req.host, 'python.org')
self.assertEqual(req.port, 443)
self.assertTrue(req.ssl)
self.loop.run_until_complete(req.close())
def test_path_is_not_double_encoded(self):
req = ClientRequest("get", "http://0.0.0.0/get/test case", loop=self.loop)
self.assertEqual(req.path, "/get/test%20case")
self.loop.run_until_complete(req.close())
req = ClientRequest("get", "http://0.0.0.0/get/test%2fcase", loop=self.loop)
self.assertEqual(req.path, "/get/test%2fcase")
self.loop.run_until_complete(req.close())
req = ClientRequest("get", "http://0.0.0.0/get/test%20case", loop=self.loop)
self.assertEqual(req.path, "/get/test%20case")
self.loop.run_until_complete(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_close(loop, buf, conn):
@aiohttp.streamer
def gen(writer):
yield from asyncio.sleep(0.00001, loop=loop)
writer.write(b'result')
req = ClientRequest(
'POST', URL('http://python.org/'), data=gen(), loop=loop)
resp = req.send(conn)
yield from req.close()
assert buf.split(b'\r\n\r\n', 1)[1] == b'6\r\nresult\r\n0\r\n\r\n'
yield from req.close()
resp.close()
def test_basic_auth_from_url(self):
req = ClientRequest('get', 'http://*****:*****@python.org',
loop=self.loop)
self.assertIn('AUTHORIZATION', req.headers)
self.assertEqual('Basic bmtpbToxMjM0', req.headers['AUTHORIZATION'])
self.loop.run_until_complete(req.close())
req = ClientRequest(
'get', 'http://[email protected]',
auth=aiohttp.helpers.BasicAuth('nkim', '1234'),
loop=self.loop)
self.assertIn('AUTHORIZATION', req.headers)
self.assertEqual('Basic bmtpbToxMjM0', req.headers['AUTHORIZATION'])
self.loop.run_until_complete(req.close())
def test_basic_auth_from_url(self):
req = ClientRequest("get", "http://*****:*****@python.org", loop=self.loop)
self.assertIn("AUTHORIZATION", req.headers)
self.assertEqual("Basic bmtpbToxMjM0", req.headers["AUTHORIZATION"])
self.assertEqual("python.org", req.netloc)
self.loop.run_until_complete(req.close())
req = ClientRequest(
"get", "http://[email protected]", auth=aiohttp.helpers.BasicAuth("nkim", "1234"), loop=self.loop
)
self.assertIn("AUTHORIZATION", req.headers)
self.assertEqual("Basic bmtpbToxMjM0", req.headers["AUTHORIZATION"])
self.assertEqual("python.org", req.netloc)
self.loop.run_until_complete(req.close())
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_close(loop, transport):
@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, buf = transport
resp = req.send(transport)
yield from req.close()
assert buf.split(b'\r\n\r\n', 1)[1] == b'6\r\nresult\r\n0\r\n\r\n'
yield from req.close()
resp.close()
def test_https_connect_pass_ssl_context(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(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_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:],
[unittest.mock.call(b"6\r\nresult\r\n"), unittest.mock.call(b"0\r\n\r\n")],
)
self.loop.run_until_complete(req.close())
resp.close()
def test_cookies(self):
req = ClientRequest("get", "http://test.com/path", cookies={"cookie1": "val1"}, loop=self.loop)
self.assertIn("COOKIE", req.headers)
self.assertEqual("cookie1=val1", req.headers["COOKIE"])
self.loop.run_until_complete(req.close())
req = ClientRequest(
"get",
"http://test.com/path",
headers={"cookie": "cookie1=val1"},
cookies={"cookie2": "val2"},
loop=self.loop,
)
self.assertEqual("cookie1=val1; cookie2=val2", req.headers["COOKIE"])
self.loop.run_until_complete(req.close())
def test_cookies(self):
req = ClientRequest(
'get', 'http://test.com/path', cookies={'cookie1': 'val1'},
loop=self.loop)
self.assertIn('COOKIE', req.headers)
self.assertEqual('cookie1=val1', req.headers['COOKIE'])
self.loop.run_until_complete(req.close())
req = ClientRequest(
'get', 'http://test.com/path',
headers={'cookie': 'cookie1=val1'},
cookies={'cookie2': 'val2'},
loop=self.loop)
self.assertEqual('cookie1=val1; cookie2=val2', req.headers['COOKIE'])
self.loop.run_until_complete(req.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_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_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_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_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_explicit_size(self, m_http):
req = ClientRequest("get", "http://python.org/", chunked=1024, loop=self.loop)
resp = 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())
resp.close()
def test_https_connect_http_proxy_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 = send_mock = mock.Mock()
send_mock.return_value = proxy_resp
proxy_resp.start = make_mocked_coro(
mock.Mock(status=400, reason='bad request'))
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(aiohttp.ClientHttpProxyError,
"400, message='bad request'"):
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_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_bytes_data(loop, conn):
for meth in ClientRequest.POST_METHODS:
req = ClientRequest(meth,
URL('http://python.org/'),
data=b'binary data',
loop=loop)
resp = req.send(conn)
assert '/' == req.url.path
assert isinstance(req.body, payload.BytesPayload)
assert b'binary data' == req.body._value
assert 'application/octet-stream' == req.headers['CONTENT-TYPE']
yield from req.close()
resp.close()
def test_precompressed_data_stays_intact(self):
data = zlib.compress(b'foobar')
req = ClientRequest(
'post', 'http://python.org/',
data=data,
headers={'CONTENT-ENCODING': 'deflate'},
compress=False,
loop=self.loop)
self.assertFalse(req.compress)
self.assertFalse(req.chunked)
self.assertEqual(req.headers['CONTENT-ENCODING'],
'deflate')
self.loop.run_until_complete(req.close())
def function1130(arg1704, function2369):
for var3597 in ClientRequest.POST_METHODS:
var1553 = ClientRequest(var3597,
URL('http://python.org/'),
data=b'binary data',
loop=arg1704)
var1897 = var1553.send(function2369)
assert ('/' == var1553.url.path)
assert isinstance(var1553.body, payload.BytesPayload)
assert (b'binary data' == var1553.body._value)
assert ('application/octet-stream' == var1553.headers['CONTENT-TYPE'])
yield from var1553.close()
var1897.close()
def function319(arg498, function2369):
var825 = ClientRequest('get',
URL('http://python.org/'),
data='foo',
compress='deflate',
loop=arg498)
with mock.patch('aiohttp.client_reqrep.PayloadWriter') as var945:
var856 = var825.send(function2369)
assert (var825.headers['TRANSFER-ENCODING'] == 'chunked')
assert (var825.headers['CONTENT-ENCODING'] == 'deflate')
var945.return_value.enable_compression.assert_called_with('deflate')
yield from var825.close()
var856.close()
def test_content_encoding_header(loop, conn):
req = ClientRequest('get',
URL('http://python.org/'),
data='foo',
headers={'Content-Encoding': 'deflate'},
loop=loop)
with mock.patch('aiohttp.client_reqrep.PayloadWriter') as m_writer:
resp = req.send(conn)
assert not m_writer.return_value.enable_compression.called
assert not m_writer.return_value.enable_chunking.called
yield from req.close()
resp.close()
def function335(arg613, function2369):
class Class174(ClientResponse):
def function2400(self, arg1241=False):
return 'customized!'
var1354 = ClientRequest('GET',
URL('http://python.org/'),
response_class=Class174,
loop=arg613)
var4445 = var1354.send(function2369)
assert ('customized!' == var4445.read())
yield from var1354.close()
var4445.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_custom_response_class(loop):
class CustomResponse(ClientResponse):
def read(self, decode=False):
return 'customized!'
req = ClientRequest('GET',
URL('http://python.org/'),
response_class=CustomResponse,
loop=loop)
resp = req.send(mock.Mock(), mock.Mock())
assert 'customized!' == resp.read()
yield from req.close()
resp.close()
def test_content_encoding(self, m_http):
req = ClientRequest('get',
'http://python.org/',
data='foo',
compress='deflate',
loop=self.loop)
resp = 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())
resp.close()
def test_custom_response_class(self):
class CustomResponse(ClientResponse):
def read(self, decode=False):
return 'customized!'
req = ClientRequest('GET',
'http://python.org/',
response_class=CustomResponse,
loop=self.loop)
resp = req.send(self.transport, self.protocol)
self.assertEqual('customized!', resp.read())
self.loop.run_until_complete(req.close())
resp.close()
def test_post_data(self):
for meth in ClientRequest.POST_METHODS:
req = ClientRequest(meth,
'http://python.org/',
data={'life': '42'},
loop=self.loop)
resp = 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())
resp.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)
resp = 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())
resp.close()
def test_post_data(loop):
for meth in ClientRequest.POST_METHODS:
req = ClientRequest(meth,
URL('http://python.org/'),
data={'life': '42'},
loop=loop)
resp = req.send(mock.Mock(), mock.Mock())
assert '/' == req.url.path
assert b'life=42' == req.body
assert 'application/x-www-form-urlencoded' ==\
req.headers['CONTENT-TYPE']
yield from req.close()
resp.close()
def test_chunked_explicit(loop):
req = ClientRequest('get',
URL('http://python.org/'),
chunked=True,
loop=loop)
with mock.patch('aiohttp.client_reqrep.aiohttp') as m_http:
resp = req.send(mock.Mock(), mock.Mock())
assert 'chunked' == req.headers['TRANSFER-ENCODING']
m_http.Request.return_value\
.add_chunking_filter.assert_called_with(8192)
yield from req.close()
resp.close()
def test_content_encoding(loop, conn):
req = ClientRequest('get',
URL('http://python.org/'),
data='foo',
compress='deflate',
loop=loop)
with mock.patch('aiohttp.client_reqrep.PayloadWriter') as m_writer:
resp = req.send(conn)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
assert req.headers['CONTENT-ENCODING'] == 'deflate'
m_writer.return_value\
.enable_compression.assert_called_with('deflate')
yield from req.close()
resp.close()
def function159(arg591, function2369):
var4401 = ClientRequest('get',
URL('http://python.org/'),
data='foo',
headers={
'Content-Encoding': 'deflate',
},
loop=arg591)
with mock.patch('aiohttp.client_reqrep.PayloadWriter') as var2842:
var3901 = var4401.send(function2369)
assert (not var2842.return_value.enable_compression.called)
assert (not var2842.return_value.enable_chunking.called)
yield from var4401.close()
var3901.close()
def function1391(arg957):
var1395 = zlib.compress(b'foobar')
var1734 = ClientRequest('post',
URL('http://python.org/'),
data=var1395,
headers={
'CONTENT-ENCODING': 'deflate',
},
compress=False,
loop=arg957)
assert (not var1734.compress)
assert (not var1734.chunked)
assert (var1734.headers['CONTENT-ENCODING'] == 'deflate')
yield from var1734.close()
def test_content_encoding(loop):
req = ClientRequest('get',
URL('http://python.org/'),
data='foo',
compress='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')
yield from req.close()
resp.close()
def function1358(self, arg6):
var742 = ClientRequest('GET',
URL('http://proxy.example.com'),
loop=self.attribute501)
arg6.return_value = var742
var607 = ClientResponse('get', URL('http://proxy.example.com'))
var607._loop = self.attribute501
var742.send = var2681 = mock.Mock()
var2681.return_value = var607
var607.start = make_mocked_coro(mock.Mock(status=200))
var566 = aiohttp.TCPConnector(loop=self.attribute501)
var566._resolve_host = make_mocked_coro([{
'hostname': 'hostname',
'host': '127.0.0.1',
'port': 80,
'family': socket.AF_INET,
'proto': 0,
'flags': 0,
}])
(var1525, var1631) = (mock.Mock(), mock.Mock())
self.attribute501.create_connection = make_mocked_coro(
(var1525, var1631))
var2225 = ClientRequest('GET',
URL('https://www.python.org'),
proxy_from_env=True,
loop=self.attribute501)
self.attribute501.run_until_complete(
var566._create_connection(var2225))
self.assertEqual(var2225.url.path, '/')
self.assertEqual(var742.method, 'CONNECT')
self.assertEqual(var742.url, URL('https://www.python.org'))
var1525.close.assert_called_once_with()
var1525.get_extra_info.assert_called_with('socket', default=None)
self.attribute501.run_until_complete(var742.close())
var607.close()
self.attribute501.run_until_complete(var2225.close())
self.assertIn('https', getproxies())
def test_data_stream_not_bytes(loop):
@asyncio.coroutine
def gen():
yield object()
req = ClientRequest('POST',
URL('http://python.org/'),
data=gen(),
loop=loop)
protocol = mock.Mock()
resp = req.send(mock.Mock(), protocol)
yield from req._writer
assert protocol.set_exception.called
yield from req.close()
resp.close()
def function2356(arg1007, function1845, function2369):
var3769 = ClientRequest('POST',
URL('http://python.org/'),
data=io.BufferedReader(io.BytesIO((b'*' * 2))),
loop=arg1007)
assert var3769.chunked
assert isinstance(var3769.body, payload.BufferedReaderPayload)
assert (var3769.headers['TRANSFER-ENCODING'] == 'chunked')
var1421 = var3769.send(function2369)
assert helpers.isfuture(var3769._writer)
yield from var1421.wait_for_close()
assert (var3769._writer is None)
assert (function1845.split(b'\r\n\r\n', 1)[1] == ((b'2\r\n' + (b'*' * 2)) +
b'\r\n0\r\n\r\n'))
yield from var3769.close()
def function2319(self, arg2208):
var4652 = ClientRequest('GET',
URL('http://proxy.example.com'),
loop=self.attribute501)
arg2208.return_value = var4652
var1046 = ClientResponse('get', URL('http://proxy.example.com'))
var1046._loop = self.attribute501
var4652.send = var1673 = mock.Mock()
var1673.return_value = var1046
var1046.start = make_mocked_coro(mock.Mock(status=200))
var2388 = aiohttp.TCPConnector(loop=self.attribute501)
var2388._resolve_host = make_mocked_coro([{
'hostname': 'hostname',
'host': '127.0.0.1',
'port': 80,
'family': socket.AF_INET,
'proto': 0,
'flags': 0,
}])
(var4139, var1856) = (mock.Mock(), mock.Mock())
self.attribute501.create_connection = make_mocked_coro(
(var4139, var1856))
var1177 = ClientRequest('GET',
URL('https://www.python.org'),
proxy=URL('http://proxy.example.com'),
loop=self.attribute501)
self.attribute501.run_until_complete(
var2388._create_connection(var1177))
self.assertEqual(var1177.url.path, '/')
self.assertEqual(var4652.method, 'CONNECT')
self.assertEqual(var4652.url, URL('https://www.python.org'))
var4139.close.assert_called_once_with()
var4139.get_extra_info.assert_called_with('socket', default=None)
self.attribute501.run_until_complete(var4652.close())
var1046.close()
self.attribute501.run_until_complete(var1177.close())
def test_https_connect(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))
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 function2366(arg2346, function2369):
for var3518 in ClientRequest.POST_METHODS:
var2498 = ClientRequest(var3518,
URL('http://python.org/'),
data={
'life': '42',
},
loop=arg2346)
var1917 = var2498.send(function2369)
assert ('/' == var2498.url.path)
assert (b'life=42' == var2498.body._value)
assert ('application/x-www-form-urlencoded' ==
var2498.headers['CONTENT-TYPE'])
yield from var2498.close()
var1917.close()
def test_data_file(loop, buf, conn):
req = ClientRequest(
'POST', URL('http://python.org/'),
data=io.BufferedReader(io.BytesIO(b'*' * 2)),
loop=loop)
assert req.chunked
assert isinstance(req.body, payload.BufferedReaderPayload)
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
resp = req.send(conn)
assert helpers.isfuture(req._writer)
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()
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 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_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.http') as m_http:
resp = req.send(mock.Mock(acquire=acquire))
assert req.headers['TRANSFER-ENCODING'] == 'chunked'
assert req.headers['CONTENT-ENCODING'] == 'deflate'
m_http.Request.return_value\
.enable_compression.assert_called_with('deflate')
m_http.Request.return_value\
.enable_chunking.assert_called_with()
yield from req.close()
resp.close()
