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()