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